Let a photograph leave: an export button, and a cache to leave from

dr-export could turn a frame into bytes and nothing could ask it to. This is
the button, and the place the bytes go.

**Everything is staged first.** An export bound for the server is written to a
local outbox and uploaded afterwards; offline is not a special case, it is the
same path with a drain that finds the server absent. Doing it the other way —
upload directly, stage only on failure — makes the failure path the one that
is rarely exercised and always broken, and a network drop mid-batch leaves
some exports existing and some not with nothing recording which. Staged first,
an export is finished the moment it is written and the upload is a promise
kept later.

The outbox sits beside the catalog rather than under the cache. dr_catalog's
cache already draws that line: passive entries are a convenience and go under
LRU, pinned ones are a promise and never do. An export awaiting upload is a
promise — the user was told it succeeded — and sweeping it for disk would
destroy the only copy. Bytes are written before the destination record, so a
kill between the two leaves an orphan the drain ignores rather than a record
pointing at nothing.

The status line says "Queued for Exports/2026", never "Exported to Nextcloud",
until it has actually landed. There is a test asserting that wording, because
the tempting shorter sentence is a claim the app cannot keep.

The drain runs on the sync pass, before the shards: a thumbnail shard can be
rebuilt from the originals and the catalog is an index, but a queued export
exists nowhere else.

`DevelopSession::render_for_export` renders the framed size rather than reusing
the frame on screen, which is deliberately viewport-sized (FR-DSP-1) — encoding
that would hand the user a soft, screen-sized file with nothing to say anything
had been lost (FR-EXP-9).

One compromise, recorded rather than hidden: the export runs synchronously on
the UI thread, so the window is unresponsive for the few hundred milliseconds
a full-resolution render and encode takes. Moving a DevelopSession and its GPU
pass to a worker is a larger change than one button earns, and it is batch
export that makes the wait intolerable rather than merely noticeable.

Still missing: the Nextcloud folder *picker*. The destination is typed into
Settings for now. `FolderBrowser` in launch.rs is already the reusable model
for it — it browses a remote tree and nothing about it is specific to choosing
a library root — but wiring it into the settings page needs a listing worker
and browser UI there, which is its own piece of work.

Carries in-flight work from a parallel session — presets, the develop copy and
paste, and the node schema's `presentation` and `enum` support. One misplaced
callback in settings_ui.rs is moved from `render` to `wire`: registered in
`render` it borrowed a `&SettingsController` into a 'static closure and would
not compile, and that file's own docs say render pushes properties while wire
connects callbacks.

992 tests pass, clippy and fmt clean. Traceability 48.3% -> 51.0%.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

core/dr-pipeline/src/lib.rs

@@ -37,6 +37,7 @@ pub mod graph;
 pub mod lens;
 pub mod operation;
 pub mod ops;
+pub mod preset;
 pub mod sidecar;
 
 pub use descriptor::{
@@ -50,6 +51,7 @@ pub use operation::{
     compose, compose_with_framing, Affects, ComposedShader, Helper, Operation, Uniform,
     RESERVED_UNIFORM_FIELDS,
 };
+pub use preset::{Preset, Scope};
 pub use sidecar::{Sidecar, Version};
 
 #[cfg(test)]

core/dr-pipeline/src/preset.rs

@@ -0,0 +1,566 @@
+//! TRACES: FR-DEV-6
+//! An edit lifted off one photograph and dropped onto another.
+//!
+//! # This is the same data a sidecar already stores
+//!
+//! A [`Preset`] is a map of `(op, param) -> value` holding only what differs
+//! from default — which is precisely [`Version::params`](crate::Version). That
+//! is not a coincidence to be tidied away later: copying settings between two
+//! images and persisting one image's settings are the same operation seen from
+//! two ends, so they share one representation and one capture routine
+//! ([`Preset::capture`], which `sidecar` calls). A second, parallel notion of
+//! "a bundle of parameter values" would be a second thing to keep in step with
+//! the descriptors.
+//!
+//! It follows that this module names no operation either, with the single
+//! exception of framing — for the reason below, which is a statement about
+//! photographs rather than about code.
+//!
+//! # Why framing is its own scope
+//!
+//! A crop is a decision about *this* photograph's composition. Copying colour
+//! from one frame to the next is what a photographer means by "make these
+//! match"; copying the crop as well re-frames every one of them to a rectangle
+//! chosen while looking at a different picture, and on a batch of forty that is
+//! forty compositions destroyed by one action.
+//!
+//! So the default [`Scope::Adjustments`] leaves the target's framing where it
+//! is, and [`Scope::Everything`] is available for the case the exclusion exists
+//! to protect against being impossible otherwise — applying one aspect ratio
+//! across a shoot. The choice is the caller's; neither is hardcoded here.
+//!
+//! # Why applying replaces rather than overlays
+//!
+//! Within its scope, [`Preset::apply`] resets first. A parameter absent from
+//! the preset means *default*, exactly as absence means default in a sidecar
+//! — so pasting a neutral edit clears the target rather than leaving the
+//! target's own exposure standing underneath. Overlaying would make the result
+//! depend on what the target happened to hold, and "these two images now match"
+//! is the whole claim the action makes.
+
+use std::collections::BTreeMap;
+
+use crate::descriptor::{OpId, ParamId};
+use crate::graph::EditGraph;
+
+/// Which part of an edit a copy carries.
+///
+/// Two variants rather than a per-operation mask because the distinction being
+/// drawn is not "which operations" but "is this about the picture's colour or
+/// about its shape". Everything in the chain but framing answers the first.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum Scope {
+    /// Colour and tone. The target keeps its own crop, straightening,
+    /// rotation and flips.
+    #[default]
+    Adjustments,
+    /// The whole edit, framing included.
+    Everything,
+}
+
+impl Scope {
+    /// Whether this scope reaches the named operation.
+    ///
+    /// Takes a `&str` rather than an [`OpId`] because the caller may be
+    /// holding a name read from a file, which has no `'static` lifetime to
+    /// offer — the sidecar path amends a parameter map without ever building
+    /// a graph.
+    pub fn covers(self, op: &str) -> bool {
+        match self {
+            Self::Everything => true,
+            Self::Adjustments => op != crate::framing::ID.0,
+        }
+    }
+}
+
+/// A set of non-default parameter values, ready to apply elsewhere.
+///
+/// Ordered, so two captures of the same edit compare equal and a caller can
+/// tell whether the clipboard actually changed.
+#[derive(Debug, Clone, PartialEq, Default)]
+pub struct Preset {
+    params: BTreeMap<(String, String), f32>,
+}
+
+impl Preset {
+    /// Every non-default parameter in `graph`.
+    ///
+    /// Walks [`EditGraph::capabilities`] — the same list the panel builds
+    /// controls from and the sidecar persists — so an operation is copyable by
+    /// virtue of being in the chain, with nothing to register (FR-DEV-3c).
+    ///
+    /// Captured at full [`Scope::Everything`]: filtering happens when the
+    /// preset is *applied*, not when it is taken. Otherwise the clipboard would
+    /// have to be re-copied to change one's mind about framing, and a preset
+    /// that had already discarded the crop could never grow it back.
+    pub fn capture(graph: &EditGraph) -> Self {
+        let mut params = BTreeMap::new();
+        for cap in graph.capabilities() {
+            for p in &cap.params {
+                if p.is_modified() {
+                    params.insert((cap.id.0.to_string(), p.id.0.to_string()), p.value);
+                }
+            }
+        }
+        Self { params }
+    }
+
+    /// Build from an already-captured parameter map — a sidecar's, typically.
+    pub fn from_params(params: BTreeMap<(String, String), f32>) -> Self {
+        Self { params }
+    }
+
+    /// The parameters, for a caller that stores them.
+    pub fn params(&self) -> &BTreeMap<(String, String), f32> {
+        &self.params
+    }
+
+    /// Consume into the parameter map.
+    pub fn into_params(self) -> BTreeMap<(String, String), f32> {
+        self.params
+    }
+
+    /// Whether this preset carries anything at all.
+    ///
+    /// An empty preset is a *neutral* edit rather than a missing one, and
+    /// applying it is meaningful: it returns the target to default. What this
+    /// answers is whether there is a clipboard to offer, which is why the UI
+    /// asks it before enabling a paste.
+    pub fn is_empty(&self) -> bool {
+        self.params.is_empty()
+    }
+
+    /// How many parameters were captured.
+    pub fn len(&self) -> usize {
+        self.params.len()
+    }
+
+    /// Whether this preset carries any framing — a crop, a rotation, a flip or
+    /// a straightening angle.
+    ///
+    /// What the interface asks to decide whether offering "include crop and
+    /// rotation" would change anything for *this* clipboard. Offering it on a
+    /// copy that has no framing in it promises an effect that cannot happen.
+    pub fn touches_framing(&self) -> bool {
+        self.params
+            .keys()
+            .any(|(op, _)| !Scope::Adjustments.covers(op))
+    }
+
+    /// How many operations this preset touches, in scope.
+    ///
+    /// For the interface's "3 adjustments" readout. Counted over operations
+    /// rather than parameters because thirty-six mixer sliders is a number
+    /// about the mixer's shape, not about how much was copied.
+    pub fn op_count(&self, scope: Scope) -> usize {
+        let mut ops: Vec<&str> = self
+            .params
+            .keys()
+            .map(|(op, _)| op.as_str())
+            .filter(|op| scope.covers(op))
+            .collect();
+        ops.sort_unstable();
+        ops.dedup();
+        ops.len()
+    }
+
+    /// Apply to a graph, replacing whatever it held within `scope`.
+    ///
+    /// Parameters this build does not recognise are skipped with a warning by
+    /// the same route a sidecar's are — a preset may have been captured by a
+    /// newer build, and an unknown name must cost its own line rather than the
+    /// paste.
+    ///
+    /// The **view is preserved**. Zoom and pan say where the user is looking,
+    /// not what the photograph is; resetting the framing would throw them back
+    /// to a fitted view mid-comparison, which reads as the paste having
+    /// navigated somewhere. This mirrors `DevelopSession::reset_framing`, and
+    /// lives here so every caller inherits it rather than each remembering.
+    pub fn apply(&self, graph: &mut EditGraph, scope: Scope) {
+        let view = graph.framing().view();
+
+        // Clear the scope first, so absence means default (see the module
+        // note). Collected before writing because `capabilities` borrows the
+        // graph and `set_param` needs it mutably.
+        let clears: Vec<(OpId, ParamId, f32)> = graph
+            .capabilities()
+            .iter()
+            .filter(|cap| scope.covers(cap.id.0))
+            .flat_map(|cap| cap.params.iter().map(|p| (cap.id, p.id, p.default)))
+            .collect();
+        for (op, param, default) in clears {
+            graph.set_param(op, param, default);
+        }
+
+        for ((op, param), value) in &self.params {
+            if !scope.covers(op) {
+                continue;
+            }
+            let Some((op, param)) = resolve(graph, op, param) else {
+                log::warn!("preset: unknown parameter {op}.{param}; ignoring");
+                continue;
+            };
+            graph.set_param(op, param, *value);
+        }
+
+        graph.framing_mut().set_view(view);
+    }
+
+    /// Apply to a parameter map — the sidecar of an image that is not open.
+    ///
+    /// The batch path. Applying to forty images by loading forty edit graphs
+    /// would mean instantiating the whole chain forty times to move some
+    /// numbers between two maps; the graph adds nothing here because there is
+    /// no rendering to do and clamping happens when the file is next read into
+    /// one ([`EditGraph::set_param`] clamps, and `Version::apply` goes through
+    /// it).
+    ///
+    /// Same replacement rule as [`Self::apply`]: the target's in-scope keys go,
+    /// the preset's arrive, and out-of-scope keys — the target's own crop, on
+    /// the default scope — are left exactly as they were.
+    pub fn amend(&self, target: &mut BTreeMap<(String, String), f32>, scope: Scope) {
+        target.retain(|(op, _), _| !scope.covers(op));
+        for ((op, param), value) in &self.params {
+            if scope.covers(op) {
+                target.insert((op.clone(), param.clone()), *value);
+            }
+        }
+    }
+}
+
+/// Find the `'static` ids matching these names, or `None` if this build has no
+/// such parameter.
+///
+/// Looking them up in the descriptors rather than leaking the caller's strings
+/// is what bounds memory: a name read from a file or carried on a clipboard
+/// never becomes a `'static`.
+pub(crate) fn resolve(graph: &EditGraph, op: &str, param: &str) -> Option<(OpId, ParamId)> {
+    let cap = graph.capabilities().into_iter().find(|c| c.id.0 == op)?;
+    let p = cap.params.iter().find(|p| p.id.0 == param)?;
+    Some((cap.id, p.id))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::framing;
+    use crate::ops::{exposure, saturation, white_balance};
+    use crate::CropRect;
+
+    /// A graph with colour *and* framing moved off default, which is what makes
+    /// the scope distinction observable.
+    fn edited() -> EditGraph {
+        let mut g = EditGraph::default_chain();
+        g.set_param(exposure::ID, exposure::EXPOSURE, 0.75);
+        g.set_param(white_balance::ID, white_balance::TEMPERATURE, 30.0);
+        g.set_crop(CropRect {
+            x: 0.1,
+            y: 0.1,
+            width: 0.5,
+            height: 0.5,
+        });
+        g.set_param(framing::ID, framing::ANGLE, -2.0);
+        g
+    }
+
+    #[test]
+    fn a_copy_carries_only_what_was_changed() {
+        // The property the whole format rests on, restated for the clipboard:
+        // a neutral operation contributes nothing, so pasting cannot carry a
+        // value the source never set.
+        let preset = Preset::capture(&edited());
+        assert!(preset
+            .params()
+            .contains_key(&("exposure".into(), "exposure".into())));
+        assert!(
+            !preset.params().keys().any(|(op, _)| op == saturation::ID.0),
+            "an untouched operation must not be copied"
+        );
+    }
+
+    #[test]
+    fn a_neutral_graph_copies_nothing() {
+        assert!(Preset::capture(&EditGraph::default_chain()).is_empty());
+    }
+
+    #[test]
+    fn a_copy_captures_framing_even_though_the_default_scope_drops_it() {
+        // Capture is deliberately unfiltered: the decision about framing is
+        // made at paste time, so a user who ticks "include crop" after copying
+        // must not have to copy again.
+        let preset = Preset::capture(&edited());
+        assert!(preset.touches_framing());
+    }
+
+    #[test]
+    fn pasting_adjustments_leaves_the_targets_composition_alone() {
+        // The case the default scope exists for: two photographs framed
+        // differently, made to match in colour without either being re-cropped.
+        let source = edited();
+        let preset = Preset::capture(&source);
+
+        let mut target = EditGraph::default_chain();
+        let target_crop = CropRect {
+            x: 0.0,
+            y: 0.25,
+            width: 1.0,
+            height: 0.5,
+        };
+        target.set_crop(target_crop);
+
+        preset.apply(&mut target, Scope::Adjustments);
+
+        assert_eq!(
+            target.param(exposure::ID, exposure::EXPOSURE),
+            Some(0.75),
+            "the colour must arrive"
+        );
+        assert!(
+            (target.crop().width - target_crop.width).abs() < 1e-5
+                && (target.crop().y - target_crop.y).abs() < 1e-5,
+            "the target's own crop must survive: {:?}",
+            target.crop()
+        );
+        assert_eq!(
+            target.param(framing::ID, framing::ANGLE),
+            Some(0.0),
+            "the source's straightening must not travel on this scope"
+        );
+    }
+
+    #[test]
+    fn pasting_everything_carries_the_composition_too() {
+        let preset = Preset::capture(&edited());
+        let mut target = EditGraph::default_chain();
+        preset.apply(&mut target, Scope::Everything);
+
+        assert_eq!(target.param(framing::ID, framing::ANGLE), Some(-2.0));
+        assert!(
+            (target.crop().width - 0.5).abs() < 1e-5,
+            "{:?}",
+            target.crop()
+        );
+    }
+
+    #[test]
+    fn pasting_replaces_rather_than_overlaying() {
+        // Pasting a neutral copy must *clear* the target. Were this an
+        // overlay, "make these match" would leave whatever the target already
+        // had underneath, and the two images would not in fact match.
+        let neutral = Preset::capture(&EditGraph::default_chain());
+
+        let mut target = EditGraph::default_chain();
+        target.set_param(exposure::ID, exposure::EXPOSURE, 2.0);
+        target.set_param(saturation::ID, saturation::SATURATION, -50.0);
+
+        neutral.apply(&mut target, Scope::Adjustments);
+
+        assert_eq!(target.param(exposure::ID, exposure::EXPOSURE), Some(0.0));
+        assert_eq!(
+            target.param(saturation::ID, saturation::SATURATION),
+            Some(0.0)
+        );
+    }
+
+    #[test]
+    fn a_paste_that_excludes_framing_does_not_clear_the_targets_framing() {
+        // The other half of the replacement rule: "replace" is scoped. A
+        // neutral paste must not straighten the target back to zero, or
+        // excluding framing would still destroy it — just to a different value.
+        let neutral = Preset::capture(&EditGraph::default_chain());
+
+        let mut target = EditGraph::default_chain();
+        target.set_param(framing::ID, framing::ANGLE, 3.5);
+
+        neutral.apply(&mut target, Scope::Adjustments);
+        assert_eq!(target.param(framing::ID, framing::ANGLE), Some(3.5));
+    }
+
+    #[test]
+    fn pasting_leaves_the_view_where_the_user_was_looking() {
+        // Zoom is navigation, not an edit. A paste that reset it would throw
+        // the user out of a 4x inspection they were making the comparison at.
+        let preset = Preset::capture(&edited());
+
+        let mut target = EditGraph::default_chain();
+        target.framing_mut().set_view(CropRect {
+            x: 0.25,
+            y: 0.25,
+            width: 0.25,
+            height: 0.25,
+        });
+
+        preset.apply(&mut target, Scope::Everything);
+        assert!(
+            target.framing().is_zoomed(),
+            "the paste threw away the viewport: {:?}",
+            target.framing().view()
+        );
+    }
+
+    #[test]
+    fn a_paste_does_not_disturb_how_the_file_stored_its_pixels() {
+        // Orientation is a fact about the target's own file. A preset copied
+        // from a landscape frame must not lay that frame's sensor scan over a
+        // portrait one — the image would open on its side.
+        let preset = Preset::capture(&edited());
+
+        let mut sideways = EditGraph::default_chain();
+        sideways.set_orientation(dr_types::Orientation::from_exif(6));
+        preset.apply(&mut sideways, Scope::Everything);
+
+        assert_eq!(
+            sideways.framing().baseline(),
+            dr_types::Orientation::from_exif(6)
+        );
+    }
+
+    #[test]
+    fn an_unknown_parameter_costs_its_own_line_and_not_the_paste() {
+        // A clipboard captured by a newer build. The rest must still apply, or
+        // one unfamiliar operation would silently discard the whole copy.
+        let mut params = BTreeMap::new();
+        params.insert(("time_machine".to_string(), "year".to_string()), 1994.0);
+        params.insert(("exposure".to_string(), "exposure".to_string()), 1.25);
+
+        let mut target = EditGraph::default_chain();
+        Preset::from_params(params).apply(&mut target, Scope::Adjustments);
+
+        assert_eq!(target.param(exposure::ID, exposure::EXPOSURE), Some(1.25));
+    }
+
+    #[test]
+    fn an_out_of_range_value_is_clamped_rather_than_trusted() {
+        let mut params = BTreeMap::new();
+        params.insert(("exposure".to_string(), "exposure".to_string()), 99.0);
+
+        let mut target = EditGraph::default_chain();
+        Preset::from_params(params).apply(&mut target, Scope::Adjustments);
+        assert_eq!(target.param(exposure::ID, exposure::EXPOSURE), Some(5.0));
+    }
+
+    // --- the batch path, which has no graph ---------------------------------
+
+    #[test]
+    fn amending_a_map_replaces_the_scope_and_spares_the_rest() {
+        let preset = Preset::capture(&edited());
+
+        // A target that has its own crop and its own, different, exposure.
+        let mut target = BTreeMap::new();
+        target.insert(("exposure".to_string(), "exposure".to_string()), -1.0);
+        target.insert(("saturation".to_string(), "saturation".to_string()), 40.0);
+        target.insert(("framing".to_string(), "crop_w".to_string()), 0.3);
+
+        preset.amend(&mut target, Scope::Adjustments);
+
+        assert_eq!(
+            target.get(&("exposure".to_string(), "exposure".to_string())),
+            Some(&0.75),
+            "the copied value must land"
+        );
+        assert!(
+            !target.contains_key(&("saturation".to_string(), "saturation".to_string())),
+            "an in-scope key the preset does not set must be cleared, not kept"
+        );
+        assert_eq!(
+            target.get(&("framing".to_string(), "crop_w".to_string())),
+            Some(&0.3),
+            "the target's own crop must survive an adjustments-only paste"
+        );
+    }
+
+    #[test]
+    fn amending_at_full_scope_replaces_the_targets_crop_too() {
+        let preset = Preset::capture(&edited());
+        let mut target = BTreeMap::new();
+        target.insert(("framing".to_string(), "crop_w".to_string()), 0.3);
+
+        preset.amend(&mut target, Scope::Everything);
+        assert_eq!(
+            target.get(&("framing".to_string(), "crop_w".to_string())),
+            Some(&0.5)
+        );
+    }
+
+    #[test]
+    fn the_map_path_and_the_graph_path_agree() {
+        // Two routes to the same result — one through a graph, one through a
+        // bare map — and a batch apply must not produce a different edit from
+        // pasting onto the image with it open. Asserted by round-tripping the
+        // amended map back through a graph and comparing every parameter.
+        let preset = Preset::capture(&edited());
+
+        for scope in [Scope::Adjustments, Scope::Everything] {
+            let mut target_graph = EditGraph::default_chain();
+            target_graph.set_param(saturation::ID, saturation::SATURATION, 20.0);
+            target_graph.set_param(framing::ID, framing::ANGLE, 4.0);
+
+            let mut target_map = Preset::capture(&target_graph).into_params();
+
+            preset.apply(&mut target_graph, scope);
+            preset.amend(&mut target_map, scope);
+
+            let mut rebuilt = EditGraph::default_chain();
+            Preset::from_params(target_map).apply(&mut rebuilt, Scope::Everything);
+
+            for cap in target_graph.capabilities() {
+                for p in &cap.params {
+                    assert_eq!(
+                        rebuilt.param(cap.id, p.id),
+                        Some(p.value),
+                        "{scope:?}: {}.{} differs between the graph and map paths",
+                        cap.id,
+                        p.id
+                    );
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn a_copy_round_trips_through_a_paste() {
+        // The end-to-end claim the feature makes: after pasting, the target
+        // holds the source's edit. Checked over the whole chain rather than a
+        // sample, so an operation that needed special handling would fail here.
+        let source = edited();
+        let preset = Preset::capture(&source);
+
+        let mut target = EditGraph::default_chain();
+        preset.apply(&mut target, Scope::Everything);
+
+        for cap in source.capabilities() {
+            for p in &cap.params {
+                assert_eq!(
+                    target.param(cap.id, p.id),
+                    Some(p.value),
+                    "{}.{} did not survive the copy",
+                    cap.id,
+                    p.id
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn operations_are_counted_in_scope() {
+        let preset = Preset::capture(&edited());
+        // exposure, white_balance and framing were touched.
+        assert_eq!(preset.op_count(Scope::Everything), 3);
+        assert_eq!(preset.op_count(Scope::Adjustments), 2);
+    }
+
+    #[test]
+    fn scope_names_framing_and_nothing_else() {
+        // The one operation this module knows by name. If a second ever
+        // appears here, it should be because someone decided it is about the
+        // picture's shape rather than because it was convenient.
+        let g = EditGraph::default_chain();
+        let excluded: Vec<&str> = g
+            .capabilities()
+            .iter()
+            .map(|c| c.id.0)
+            .filter(|id| !Scope::Adjustments.covers(id))
+            .collect();
+        assert_eq!(excluded, vec![framing::ID.0]);
+    }
+}

core/dr-pipeline/src/sidecar.rs

@@ -66,8 +66,8 @@ use std::collections::BTreeMap;
 use std::fmt;
 use std::fmt::Write as _;
 
-use crate::descriptor::{OpId, ParamId};
 use crate::graph::EditGraph;
+use crate::preset::{resolve, Preset};
 
 /// Format version of the document itself.
 ///
@@ -348,27 +348,13 @@ fn merge_judgement(ours: u8, theirs: u8, remote_wins: bool) -> u8 {
 /// Reads [`EditGraph::capabilities`] — the same list the UI builds controls
 /// from — so an operation is persisted by virtue of being in the chain, with
 /// nothing to register and nothing to forget.
-fn capture(graph: &EditGraph) -> BTreeMap<(String, String), f32> {
-    let mut out = BTreeMap::new();
-    for cap in graph.capabilities() {
-        for p in &cap.params {
-            if p.is_modified() {
-                out.insert((cap.id.0.to_string(), p.id.0.to_string()), p.value);
-            }
-        }
-    }
-    out
-}
-
-/// Find the `'static` ids matching these names, or `None` if this build has
-/// no such parameter.
 ///
-/// Looking them up in the descriptors rather than leaking the file's strings
-/// is what bounds memory: an unrecognised name never becomes a `'static`.
-fn resolve(graph: &EditGraph, op: &str, param: &str) -> Option<(OpId, ParamId)> {
-    let cap = graph.capabilities().into_iter().find(|c| c.id.0 == op)?;
-    let p = cap.params.iter().find(|p| p.id.0 == param)?;
-    Some((cap.id, p.id))
+/// Delegated to [`Preset::capture`] rather than reimplemented: a version's
+/// parameters and a copied preset are the same values taken from the same
+/// list, and two routines building the same map would be two places for the
+/// non-default rule to drift.
+fn capture(graph: &EditGraph) -> BTreeMap<(String, String), f32> {
+    Preset::capture(graph).into_params()
 }
 
 impl Sidecar {

core/dr-types/src/lib.rs

@@ -13,8 +13,8 @@ pub mod settings;
 
 pub use selector::{ColourLabel, DateSelector, FlagState, Selector, Tier};
 pub use settings::{
-    CacheSettings, CollisionPolicy, ColourSpace, ExportFormat, ExportSettings, ExportTarget,
-    OutputSharpening, Settings, SizingMode,
+    CacheSettings, CollisionPolicy, ColourSpace, DevelopSettings, ExportFormat, ExportSettings,
+    ExportTarget, OutputSharpening, Settings, SizingMode,
 };
 
 /// Identifies a granted library location — a directory on Linux, a persisted

core/dr-types/src/settings.rs

@@ -51,6 +51,38 @@ use serde::{Deserialize, Serialize};
 pub struct Settings {
     pub cache: CacheSettings,
     pub export: ExportSettings,
+    pub develop: DevelopSettings,
+}
+
+// ---------------------------------------------------------------------------
+// Develop
+// ---------------------------------------------------------------------------
+
+/// TRACES: FR-DEV-6
+/// How the develop tools behave, where the answer is a matter of taste rather
+/// than of correctness.
+#[derive(Debug, Clone, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default)]
+pub struct DevelopSettings {
+    /// Whether copying settings carries crop, straightening, rotation and
+    /// flips onto the images they are pasted to.
+    ///
+    /// **Off by default, deliberately.** A crop is a decision about one
+    /// photograph's composition; carrying it to the next re-frames a picture
+    /// that was composed differently, and applied across a selection of forty
+    /// it destroys forty compositions in one action that looks like a
+    /// colour-matching step. Colour is what "make these match" almost always
+    /// means.
+    ///
+    /// It is a setting rather than a fixed rule because the excluded case is
+    /// real and otherwise unreachable: applying one aspect ratio across a
+    /// shoot is a legitimate thing to want, and there would be no way to ask
+    /// for it.
+    ///
+    /// A device preference rather than a per-paste prompt — a photographer who
+    /// works one way works that way every time, and a dialogue on every paste
+    /// would be a question with the same answer forty times over.
+    pub copy_includes_framing: bool,
 }
 
 // ---------------------------------------------------------------------------