LightCraft: An open-source non-destructive photo editor written by scratch in pure Rust
M3: honour Nikon CropArea and embedded preview colour space
Hanmo024e983a7ee6
diff --git a/crates/codecs/README.md b/crates/codecs/README.mdindex d826b5ec1..05824eb02 100644--- a/crates/codecs/README.md+++ b/crates/codecs/README.md@@ -56,6 +56,10 @@ or CMYK profile converted by the CMS straight to linear Rec.2020), `Container` (EXIF `R03` Adobe RGB hint), `Untagged` (assumed sRGB; untagged float data assumed linear),`IccUnsupported` (profile present but unusable → **sRGB fallback**), `Naive` (CMYK without profile).+`decode_jpeg_with_fallback(bytes, opts, space)` lets an enclosing RAW container supply the colour+space of a JPEG with no ICC or EXIF metadata. It applies the transfer curve before linear-light+resizing; a JPEG carrying its own metadata retains its existing interpretation.+ICC profiles are parsed with `moxcms` (v2/v4, `curv`/`para` TRCs, `chad`); sRGB, Display P3,Adobe RGB (1998), ProPhoto (ROMM) and Rec.2020 are recognised by colorants. `icc::write_matrix_trc`emits v4 display profiles (D50 PCS, Bradford `chad`) for export embedding.diff --git a/crates/codecs/src/jpeg.rs b/crates/codecs/src/jpeg.rsindex 0096f9059..ce8712ade 100644--- a/crates/codecs/src/jpeg.rs+++ b/crates/codecs/src/jpeg.rs@@ -105,6 +105,10 @@ pub(crate) fn parse_markers(b: &[u8]) -> Option<Markers> {}pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {+ decode_with_fallback(bytes, opts, None)+}++pub(crate) fn decode_with_fallback(bytes: &[u8], opts: &DecodeOptions, fallback: Option<crate::NamedSpace>) -> Result<Decoded> {let m = parse_markers(bytes).ok_or_else(|| Error::Malformed(F, "missing SOI".into()))?;if m.components == 0 {return Err(Error::Malformed(F, "no frame header".into()));@@ -119,7 +123,10 @@ pub(crate) fn decode(bytes: &[u8], opts: &DecodeOptions) -> Result<Decoded> {} else {decode_zune(bytes, &m)?};- let meta = Meta { icc: m.icc, exif: m.exif, xmp: m.xmp, ..Default::default() };+ // A raw container may carry the colour declaration of an otherwise untagged preview.+ // Apply it before linearization/resizing; existing JPEG metadata always wins.+ let hint = fallback.filter(|_| m.icc.is_none() && m.exif.is_none()).map(|space| crate::SourceSpace::named(space, crate::SpaceOrigin::Container));+ let meta = Meta { icc: m.icc, exif: m.exif, xmp: m.xmp, hint, ..Default::default() };finish(F, raw, meta, (m.width, m.height), opts)}@@ -246,6 +253,44 @@ fn mpf_images(m: &Markers) -> Vec<(usize, usize)> {mod tests {use super::*;+ #[test]+ fn container_fallback_matches_tagged_jpeg_before_resizing_and_keeps_own_metadata() {+ use crate::{ChromaSubsampling, EncodeImage, EncodeMeta, NamedSpace, Samples, SpaceOrigin, encode_jpeg};+ let pixels: Vec<u8> = (0..16 * 16).flat_map(|i| if i % 2 == 0 { [120, 180, 90] } else { [30, 100, 200] }).collect();+ let encode = |icc, exif| {+ encode_jpeg(+ &EncodeImage::new(16, 16, 3, Samples::U8(&pixels)),+ 100,+ ChromaSubsampling::S444,+ &EncodeMeta { icc, exif, ..Default::default() },+ )+ .unwrap()+ };+ let untagged = encode(None, None);+ let adobe = crate::icc::write_named(NamedSpace::AdobeRgb);+ let tagged = encode(Some(&adobe), None);+ for opts in [DecodeOptions::default(), DecodeOptions::fit(3, 3)] {+ let with = crate::decode_jpeg_with_fallback(&untagged, opts, NamedSpace::AdobeRgb).unwrap();+ let expected = crate::decode(&tagged, opts).unwrap();+ assert_eq!(with.space.origin, SpaceOrigin::Container);+ let (a, b) = (with.to_working(), expected.to_working());+ for (p, q) in a.data.iter().zip(&b.data) {+ assert!(p.iter().zip(q).all(|(a, b)| (a - b).abs() < 0.0001), "{p:?} != {q:?}");+ }+ }+ let srgb = crate::icc::write_named(NamedSpace::Srgb);+ let exif = crate::exif::minimal_exif(6);+ for bytes in [encode(Some(&srgb), None), encode(None, Some(&exif)), encode(Some(b"bad ICC"), None)] {+ let opts = DecodeOptions::fit(5, 5);+ let with = crate::decode_jpeg_with_fallback(&bytes, opts, NamedSpace::AdobeRgb).unwrap();+ let expected = crate::decode(&bytes, opts).unwrap();+ assert_eq!(with.space, expected.space);+ assert_eq!(with.image, expected.image);+ assert_eq!(with.orientation, expected.orientation);+ }+ assert!(crate::decode_jpeg_with_fallback(b"bad JPEG", DecodeOptions::default(), NamedSpace::AdobeRgb).is_err());+ }+#[test]fn scaled_request_covers() {assert_eq!(scaled_request(6000, 4000, 256, 256), (256, 171));diff --git a/crates/codecs/src/lib.rs b/crates/codecs/src/lib.rsindex 708aa9b79..0328f33c0 100644--- a/crates/codecs/src/lib.rs+++ b/crates/codecs/src/lib.rs@@ -156,6 +156,14 @@ pub fn decode(bytes: &[u8], opts: DecodeOptions) -> Result<Decoded> {std::panic::catch_unwind(|| decode_unguarded(bytes, format, &opts)).unwrap_or_else(|_| Err(Error::Malformed(format, "decoder panicked".into())))}+/// Decode a JPEG preview with its enclosing container's colour space as a fallback.+/// A JPEG carrying ICC or EXIF metadata keeps its own interpretation. The fallback is applied+/// before transfer decoding and linear-light resizing, never to already-resampled pixels.+pub fn decode_jpeg_with_fallback(bytes: &[u8], opts: DecodeOptions, fallback: NamedSpace) -> Result<Decoded> {+ std::panic::catch_unwind(|| jpeg::decode_with_fallback(bytes, &opts, Some(fallback)))+ .unwrap_or_else(|_| Err(Error::Malformed(Format::Jpeg, "decoder panicked".into())))+}+/// [`decode`] without the panic guard (for fuzzing our own code paths).#[doc(hidden)]pub fn decode_unguarded(bytes: &[u8], format: Format, opts: &DecodeOptions) -> Result<Decoded> {diff --git a/crates/engine/src/camera_preview.rs b/crates/engine/src/camera_preview.rsindex cd0d475d2..fed75bebc 100644--- a/crates/engine/src/camera_preview.rs+++ b/crates/engine/src/camera_preview.rs@@ -60,9 +60,8 @@ pub(crate) fn fit_preview(raw: &RawImage, bytes: &[u8], transform: &CameraTransf/// Same-size proxies of the sensor (white-balanced, baseline exposure, through `transform`'s/// matrix: the generic camera ≈ sRGB model) and of the file's embedded camera JPEG (linear Rec.2020).fn proxies(raw: &RawImage, bytes: &[u8], transform: &CameraTransform, size: usize) -> Option<(Rgb32f, Rgb32f)> {- let jpeg = lightcraft_raw::embedded_preview(bytes)?;let edge = (2 * size).max(384) as u32;- let decoded = lightcraft_codecs::decode(&jpeg, lightcraft_codecs::DecodeOptions { max_size: Some((edge, edge)), max_pixels: 64_000_000 }).ok()?;+ let decoded = crate::files::decode_raw_preview(bytes, lightcraft_codecs::DecodeOptions { max_size: Some((edge, edge)), max_pixels: 64_000_000 })?;let mut reference = decoded.to_working();let (a, crop) = (raw.active_area, raw.crop.clipped(raw.active_area.width, raw.active_area.height));if crop.width == 0 || crop.height == 0 || reference.width == 0 || reference.height == 0 {diff --git a/crates/engine/src/files.rs b/crates/engine/src/files.rsindex 62a1c467f..183efceec 100644--- a/crates/engine/src/files.rs+++ b/crates/engine/src/files.rs@@ -320,6 +320,21 @@ fn preview_orientation(raw_bytes: &[u8], jpeg_orientation: u16) -> Orientation {lightcraft_meta::extract(raw_bytes).orientation.unwrap_or(Orientation::Normal)}+/// Shared colour interpretation for quick previews, unsupported RAW fallback and camera-look fitting.+pub(crate) fn decode_raw_preview(bytes: &[u8], opts: lightcraft_codecs::DecodeOptions) -> Option<lightcraft_codecs::Decoded> {+ let jpeg = lightcraft_raw::embedded_preview(bytes)?;+ match lightcraft_raw::embedded_preview_color_space(bytes) {+ Some(space) => {+ let space = match space {+ lightcraft_raw::PreviewColorSpace::Srgb => lightcraft_codecs::NamedSpace::Srgb,+ lightcraft_raw::PreviewColorSpace::AdobeRgb => lightcraft_codecs::NamedSpace::AdobeRgb,+ };+ lightcraft_codecs::decode_jpeg_with_fallback(&jpeg, opts, space).ok()+ }+ None => lightcraft_codecs::decode(&jpeg, opts).ok(),+ }+}+/// Oriented size of the embedded preview of a raw file.fn embedded_preview_size(bytes: &[u8]) -> Option<(u32, u32)> {let jpeg = lightcraft_raw::embedded_preview(bytes)?;@@ -333,8 +348,7 @@ fn embedded_preview_size(bytes: &[u8]) -> Option<(u32, u32)> {/// The embedded preview of a raw file as a working-space image no larger than `max_edge`, oriented.pub fn load_embedded_preview(bytes: &[u8], max_edge: usize) -> Option<(Rgb32f, SourceInfo)> {- let jpeg = lightcraft_raw::embedded_preview(bytes)?;- let d = lightcraft_codecs::decode(&jpeg, lightcraft_codecs::DecodeOptions::fit(max_edge as u32, max_edge as u32)).ok()?;+ let d = decode_raw_preview(bytes, lightcraft_codecs::DecodeOptions::fit(max_edge as u32, max_edge as u32))?;let img = d.to_working();let img = if img.width.max(img.height) > max_edge { fit(&img, max_edge, max_edge, Filter::Mitchell) } else { img };Some((img.oriented(preview_orientation(bytes, d.orientation)), SourceInfo::default()))@@ -343,8 +357,7 @@ pub fn load_embedded_preview(bytes: &[u8], max_edge: usize) -> Option<(Rgb32f, S/// The embedded preview of a raw file for display (sRGB, oriented, no larger than `max_edge`): the/// loupe and grid show it until the raw itself has been developed ([`crate::media::QuickJob`]).pub fn embedded_preview_srgb(bytes: &[u8], max_edge: usize) -> Option<lightcraft_raster::Rgba8> {- let jpeg = lightcraft_raw::embedded_preview(bytes)?;- let mut d = lightcraft_codecs::decode(&jpeg, lightcraft_codecs::DecodeOptions::fit(max_edge as u32, max_edge as u32)).ok()?;+ let mut d = decode_raw_preview(bytes, lightcraft_codecs::DecodeOptions::fit(max_edge as u32, max_edge as u32))?;if d.image.width.max(d.image.height) > max_edge {d.image = fit(&d.image, max_edge, max_edge, Filter::Box);d.alpha = None;diff --git a/crates/engine/src/media.rs b/crates/engine/src/media.rsindex 76a9bf1a2..7aafbf349 100644--- a/crates/engine/src/media.rs+++ b/crates/engine/src/media.rs@@ -62,7 +62,7 @@ impl SettingsHashes {}/// Bump when the pipeline's output changes, to invalidate cached thumbnails.-pub const RENDER_CACHE_VERSION: u64 = 11;+pub const RENDER_CACHE_VERSION: u64 = 12;/// Thumbnails render at one of these long edges (so window/cell size changes reuse the cache).pub const THUMB_SIZES: [usize; 4] = [128, 256, 384, 512];diff --git a/crates/raw/src/lib.rs b/crates/raw/src/lib.rsindex f67649de8..e53550aea 100644--- a/crates/raw/src/lib.rs+++ b/crates/raw/src/lib.rs@@ -43,7 +43,7 @@ pub use lightcraft_geom::Orientation;pub use lightcraft_meta::Metadata;pub use lightcraft_raster::Rgb32f;pub use opcodes::{Opcode, OpcodeLists};-pub use preview::embedded_preview;+pub use preview::{PreviewColorSpace, embedded_preview, embedded_preview_color_space};use lightcraft_color::Xy;use lightcraft_tiff::{Tiff, TiffError};diff --git a/crates/raw/src/preview.rs b/crates/raw/src/preview.rsindex ded35d294..42b5d70be 100644--- a/crates/raw/src/preview.rs+++ b/crates/raw/src/preview.rs@@ -5,6 +5,30 @@ use lightcraft_tiff::image::chunk_bytes;use lightcraft_tiff::tags as t;use lightcraft_tiff::{Ifd, Tiff, makernote};+/// Colour space of an embedded JPEG when the enclosing raw supplies it instead of the JPEG.+#[derive(Clone, Copy, Debug, PartialEq, Eq)]+pub enum PreviewColorSpace {+ Srgb,+ AdobeRgb,+}++/// Nikon maker-note ColorSpace (0x001e: 1 = sRGB, 2 = Adobe RGB), per Nikon tag documentation.+/// This is a fallback only: a JPEG's own ICC/EXIF colour declaration takes precedence.+pub fn embedded_preview_color_space(bytes: &[u8]) -> Option<PreviewColorSpace> {+ let tiff = Tiff::parse(bytes).ok()?;+ let make = tiff.ifds.first()?.string(t::MAKE)?;+ if !make.to_ascii_uppercase().starts_with("NIKON") {+ return None;+ }+ let e = tiff.exif()?.get(t::MAKER_NOTE)?;+ let mn = makernote::parse_makernote(bytes, e.offset, e.count() as u64, tiff.order, &make)?;+ match mn.ifd.u16(0x001e)? {+ 1 => Some(PreviewColorSpace::Srgb),+ 2 => Some(PreviewColorSpace::AdobeRgb),+ _ => None,+ }+}+/// Whether `b` looks like a displayable (DCT) JPEG: SOI, and the first SOF marker is not lossless.fn is_dct_jpeg(b: &[u8]) -> bool {if b.len() < 4 || b[0] != 0xff || b[1] != 0xd8 {diff --git a/crates/raw/src/vendor/nef.rs b/crates/raw/src/vendor/nef.rsindex bf386bb4b..8d1898e0f 100644--- a/crates/raw/src/vendor/nef.rs+++ b/crates/raw/src/vendor/nef.rs@@ -17,6 +17,19 @@ use lightcraft_tiff::{ByteOrder, Ifd, Tiff, makernote};const WB_RB_LEVELS: u16 = 0x000c;const BLACK_LEVEL: u16 = 0x003d;const LINEARIZATION_TABLE: u16 = 0x0096;+const CROP_AREA: u16 = 0x0045;++/// Nikon CropArea is `[left, top, width, height]` in sensor pixels (maker-note tag documentation).+/// Keep the active area/CFA origin unchanged: the default crop is applied after demosaicing.+fn default_crop(mn: Option<&makernote::MakerNote>, w: usize, h: usize) -> Rect {+ let fallback = Rect::new(0, 0, w, h);+ let Some(values) = mn.and_then(|m| m.ifd.u64s(CROP_AREA)) else { return fallback };+ let [x, y, width, height] = values.as_slice() else { return fallback };+ if *width == 0 || *height == 0 || x.checked_add(*width).is_none_or(|v| v > w as u64) || y.checked_add(*height).is_none_or(|v| v > h as u64) {+ return fallback;+ }+ Rect::new(*x as usize, *y as usize, *width as usize, *height as usize)+}fn raw_ifd(tiff: &Tiff) -> Option<&Ifd> {tiff.all_ifds()@@ -80,9 +93,10 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {};let white = white_from_data(samples, bits);let active_w = trailing_masked_columns(samples, w, h, white);+ let crop = default_crop(mn.as_ref(), active_w, h);let mut metadata = lightcraft_meta::from_tiff(&tiff);- metadata.width = Some(active_w as u32);- metadata.height = Some(h as u32);+ metadata.width = Some(crop.width as u32);+ metadata.height = Some(crop.height as u32);let img = RawImage {format: RawFormat::Nef,width: w,@@ -94,7 +108,7 @@ pub(crate) fn decode(bytes: &[u8]) -> Result<RawImage> {black,white: vec![white],active_area: Rect::new(0, 0, active_w, h),- crop: Rect::new(0, 0, active_w, h),+ crop,orientation: Orientation::from_exif(ifd0.u16(t::ORIENTATION).unwrap_or(1)),color: ColorData::default(),wb_multipliers: wb,@@ -181,6 +195,42 @@ mod tests {TiffWriter::new(ByteOrder::Big, false).write(&[ifd0]).unwrap()}+ #[test]+ fn preview_color_space_is_read_from_the_nikon_note() {+ for (value, expected) in [(1, Some(crate::PreviewColorSpace::Srgb)), (2, Some(crate::PreviewColorSpace::AdobeRgb)), (3, None)] {+ let mut mn = IfdBuilder::new();+ mn.set(0x001e, Value::Short(vec![value]));+ let bytes = nef_with_note(1, 14, vec![vec![0; 128]], 8, 8, 8, Some(mn));+ assert_eq!(crate::embedded_preview_color_space(&bytes), expected);+ }+ assert_eq!(crate::embedded_preview_color_space(&nef(1, 14, vec![vec![0; 128]], 8, 8, 8)), None);+ assert_eq!(crate::embedded_preview_color_space(b"not a TIFF"), None);+ }++ #[test]+ fn nikon_crop_area_preserves_sensor_origin_and_rejects_invalid_rectangles() {+ let (w, h) = (32, 24);+ let words: Vec<u8> = (0..w * h).flat_map(|i| (100 + i as u16).to_be_bytes()).collect();+ for (values, expected) in [+ (vec![2, 4, 28, 16], Rect::new(2, 4, 28, 16)),+ (vec![31, 4, 28, 16], Rect::new(0, 0, 32, 24)),+ (vec![2, 4, 0, 16], Rect::new(0, 0, 32, 24)),+ (vec![u32::MAX, 4, 28, 16], Rect::new(0, 0, 32, 24)),+ (vec![2, 4, 28], Rect::new(0, 0, 32, 24)),+ ] {+ let mut mn = IfdBuilder::new();+ mn.set(CROP_AREA, Value::Long(values));+ let bytes = nef_with_note(1, 14, vec![words.clone()], w, h, h, Some(mn));+ let raw = crate::decode(&bytes).unwrap();+ assert_eq!(raw.crop, expected);+ assert_eq!(raw.active_area, Rect::new(0, 0, 32, 24));+ assert_eq!(raw.metadata.width, Some(expected.width as u32));+ assert_eq!(raw.metadata.height, Some(expected.height as u32));+ let developed = raw.develop(crate::Method::Bilinear).unwrap();+ assert_eq!((developed.width, developed.height), (expected.width, expected.height));+ }+ }+#[test]fn black_level_tag_is_in_14_bit_units() {let (w, h) = (16usize, 4usize);diff --git a/docs/camera-preview-colour.md b/docs/camera-preview-colour.mdindex 308287c6c..6224547c7 100644--- a/docs/camera-preview-colour.md+++ b/docs/camera-preview-colour.md@@ -54,3 +54,12 @@ One photo can show too little of a colour for its own fit to learn it: in a secoProfiles are JSON files `<model>.json` in `$LIGHTCRAFT_CAMERA_PROFILES`, else `<config>/camera-profiles` (macOS `~/Library/Application Support/LightCraft/camera-profiles`); a local profile replaces a built-in one. Built-in profiles live in `assets/camera-profiles/` (listed in `assets/ATTRIBUTION.md`) and are compiled in, so the app, CLI and web build share them: ILCE-7M4, fitted to 597 photos (2.2 million colour pairs) shot in 2026, mostly with the Standard creative style and DRO Auto. They hold aggregate colour statistics only. A photo of a profiled model takes its colour from the profile and fits only its own tone and chroma curves (DRO and picture styles vary per shot); the acceptance gates still apply, and a rejected fit falls back as before. Files are read once per process and validated (version, bounded invertible matrix, table shape and finite data); a damaged file is ignored with a warning. The profiles folder's contents are part of the render cache keys, so thumbnails rendered before a profile existed are redone; smart previews built before keep their colour until rebuilt.+++## Nikon crop and preview colour metadata++Nikon maker-note `CropArea` (0x0045) supplies the default `[left, top, width, height]` crop. The decoder validates the rectangle against the active sensor area and falls back to that area for missing or invalid values. The CFA origin is unchanged; cropping follows demosaicing.++An embedded JPEG with neither ICC nor EXIF metadata uses Nikon maker-note `ColorSpace` (0x001e: 1 = sRGB, 2 = Adobe RGB). This fallback is applied before transfer decoding and resizing, and used by quick previews, preview-only RAW and the existing camera-look reference decode. A JPEG's own metadata takes precedence. No fitting algorithm, training split, highlight reconstruction or white-balance control changes are included. Render cache version 12 invalidates older previews.++Synthetic tests cover crop bounds/CFA preservation, colour-space tags, fallback transfer decoding and metadata precedence. A private Nikon Z 8 sample reports an 8256 × 5504 default crop from an 8280 × 5520 sensor. No private sample or Adobe asset is included.diff --git a/docs/parity.md b/docs/parity.mdindex d5a31ea9c..dfa45a530 100644--- a/docs/parity.md+++ b/docs/parity.md@@ -59,7 +59,7 @@ Ordered by user impact, then tier, then effort. The checklist above counts featuthat decide whether a photographer can switch (see the honest assessment in [ROADMAP.md](../ROADMAP.md#where-we-stand)).Take the first one nobody is working on.-1. **LR-PROF-CAMERACOLOR** (P0): our own camera colour calibration. Sony ARW, Nikon NEF and Panasonic RW2 now get a guarded file-local fit to their own embedded JPEG (colour matrix + hue/saturation/value table + tone and chroma curves, relative WB; per-model profiles pooled from many photos via `lightcraft-cli calibrate` for ARW and NEF; ARW: 7 of 10 public samples accepted, mean ΔE vs the camera JPEG 17–26 → 3–10; NEF: 13 of 13 decodable samples from 6 bodies accepted, ΔE 13–46 → 3–8, one mixed-light scene 13 → 12; RW2: 140 of 174 public samples accepted, from 93 of the 114 bodies with a preview, median ΔE 5.0); measured calibration and fidelity remain missing. Other non-DNG raws and rejected fits still use a neutral matrix. Expand validated preview fitting and use matrices the files carry themselves; never Adobe data.+1. **LR-PROF-CAMERACOLOR** (P0): our own camera colour calibration. Sony ARW, Nikon NEF and Panasonic RW2 now get a guarded file-local fit to their own embedded JPEG (colour matrix + hue/saturation/value table + tone and chroma curves, relative WB; per-model profiles pooled from many photos via `lightcraft-cli calibrate` for ARW and NEF; ARW: 7 of 10 public samples accepted, mean ΔE vs the camera JPEG 17–26 → 3–10; NEF: 13 of 13 decodable samples from 6 bodies accepted, ΔE 13–46 → 3–8, one mixed-light scene 13 → 12; RW2: 140 of 174 public samples accepted, from 93 of the 114 bodies with a preview, median ΔE 5.0); Nikon CropArea and untagged-preview ColorSpace metadata are respected; measured calibration and fidelity remain missing. Other non-DNG raws and rejected fits still use a neutral matrix. Expand validated preview fitting and use matrices the files carry themselves; never Adobe data.2. **LR-IMP-FORMATS** (P0): **CR3** first (every Canon body since ~2018), then compressed RAF / ORF, Nikon"lossy after split" NEF, Canon sRAW; HEIC/AVIF decode. Clean-room, from prose descriptions only (see`crates/raw/src/vendor/nefc.rs` for how compressed NEF was done). Until decoded, such photos are `preview_only`.@@ -125,7 +125,7 @@ under the UI command that wraps it (a no-op error); the UI command now wins.| LR-IMP-LOCAL | Work on files in place | P0 | ✅ | `cmd:library.browse`, `cmd:photo.addToLibrary`, `cmd:library.import` (mode add), `cmd:local.addRoot`, `cmd:local.hide`, `cmd:local.restoreHidden`, `crates/engine/src/cmd/browse.rs`, `crates/ui-egui/src/panels/left.rs` (`local_section`), `crates/ui-egui/src/panels/grid.rs` (`folder_header`) | Local: browse Pictures / Desktop / Downloads / Home or any folder without adding it (breadcrumb, Include subfolders, Add N to My Photos); browsed photos stay out of All Photos, albums and counts; folders picked with Browse Folder… (or Keep in Local / Add to Local on a folder row) stay listed across restarts, and browsing a folder inside a listed one highlights it inside that tree (opened down to it, siblings reachable) instead of adding a root; edits go to XMP sidecars; importing promotes them; right-click a top-level location → Remove from Local hides the shortcut only (nothing on disk or in the catalog changes), saved with the UI state, and “Show N hidden locations” (or Browse Folder… on it) brings it back; a folder is one location however its path is spelled (`/` or `\`, trailing separator, `.`/`..`, drive-letter case; `folder_key` in `crates/catalog/src/query.rs`); browsed photos nobody changed are forgotten once their folder has not been browsed for 30 days (Settings → Performance → Local folders, 0 = never; checked when the library opens, or `cmd:library.forgetLocal` with `dryRun`; files and sidecars stay, browsing again brings them back; see `crates/catalog/src/local.rs` for what counts as a change) || LR-IMP-SIDECAR-SPLIT | Separate XMP sidecar variants | P2 | ⬜ | `cmd:library.xmpPreferences` | sidecar naming option exists (stem/full), no split sidecars || LR-IMP-FORMATS | Supported formats | P0 | 🟡 | `crates/codecs/src/lib.rs`, `crates/raw/src/lib.rs` | JPEG, PNG, TIFF, WebP, JXL, PSD, GIF, BMP; DNG (incl. lossy / Smart Preview DNG), CR2 (colour-filter layout from the file's `CR2CFAPattern` tag, issue #85), ARW (pre-2017 bodies: white balance and black level from enciphered maker-note / `SR2SubIFD` data, issue #148; downsized Sony lossless YCbCr 4:2:0 / 4:2:2 tiles decoded to linear RGB, verified on private ILCE-7M4 3:2 & 4:3 examples including 16-bit full-resolution export), NEF (uncompressed, lossless and lossy compressed 12/14-bit, `crates/raw/src/vendor/nefc.rs`), RAF, RW2 / Leica RWL / Panasonic RAW in every raw format (compressed 4 and 6, the prefix-coded strips of format 8 from the GH6 on, packed 2/5/7, the 16-bit words of the 2005–2007 bodies; black levels, in-camera aspect crops and mapped-out defect pixels; 178 CC0 files from 118 bodies checked, `crates/raw/src/vendor/rw2.rs`), PEF, ORF. 12-bit NEF black level: maker note `0x003d` is in 14-bit units (D750, D780, D850, D7500, Z 50 checked). CR3 opens from its full-size embedded JPEG with full metadata (Exif, GPS, XMP from the `CMT1`/`CMT2`/`CMT4` boxes, `crates/meta/src/cr3.rs`) but its raw data is not decoded yet. Missing: CR3 raw decoding (CRX), compressed RAF/ORF, NEFs labelled compressed (34713) but stored uncompressed without a `0x0096` table (Z 6 packed 14-bit, D850 12-bit uncompressed), NEF "lossy after split" (preview only: imported with `preview_only` = the decoder's reason, rendered as a rendered JPEG, flagged by a grid badge and loupe/Edit/Info notices, `previewOnly` in `catalog.query`; Reload clears it once the file decodes), HEIC/AVIF decode |-| LR-IMP-CAMERA-COVERAGE | Camera coverage, verified per model | P0 | 🟡 | `crates/raw/tests/corpus.rs`, `xtask/src/main.rs` | a supported container is not the same as every camera that writes it decoding correctly: ~55 CC0 corpus files (plus ~60 NEFs checked by hand and 178 Panasonic / Leica RW2, RWL and RAW files from 118 bodies, checked against each file's own JPEG) against the >1,000 models Lightroom lists; per-model differences still surface (e.g. the CR2 colour-filter layout differed by model until it was read from the file's own tag, issue #85, checked on 35 CR2 bodies; pre-2017 Sony ARWs opened green until their scrambled white balance / black level were read, issue #148, checked on 16 ARWs from 15 Sony bodies). Grow the CC0 corpus per model and test each sample decodes with plausible colour |+| LR-IMP-CAMERA-COVERAGE | Camera coverage, verified per model | P0 | 🟡 | `crates/raw/tests/corpus.rs`, `xtask/src/main.rs` | a supported container is not the same as every camera that writes it decoding correctly: ~55 CC0 corpus files (plus ~60 NEFs checked by hand and 178 Panasonic / Leica RW2, RWL and RAW files from 118 bodies, checked against each file's own JPEG) against the >1,000 models Lightroom lists; per-model differences still surface (e.g. the CR2 colour-filter layout differed by model until it was read from the file's own tag, issue #85, checked on 35 CR2 bodies; pre-2017 Sony ARWs opened green until their scrambled white balance / black level were read, issue #148, checked on 16 ARWs from 15 Sony bodies). Grow the CC0 corpus per model and test each sample decodes with plausible colour. Nikon CropArea and untagged-preview colour-space regression tests; private Z 8 crop verified. || LR-IMP-CULL-AT-IMPORT | Culling analysis at import | P2 | 🟡 | `cmd:photo.analyze` | run Assisted Culling on the imported photos (they're selected after an import); not automatic || LR-IMP-MOVE | Move on import [Classic] | P1 | ✅ | `cmd:library.import` (`mode` move), `crates/engine/src/import_move.rs`, `crates/engine/src/tests_import_move.rs`, `crates/ui-egui/src/import.rs` | Transfer ▸ Move with Copy's destination, folders (day / month / one folder / custom template), rename template and example destination; XMP sidecars (both namings) move along; each source is removed only after its destination is written (hard link on the same volume, else copied, synced and compared byte for byte) and its catalog record is saved; failed, duplicate, unchecked files keep their sources, taken names get -1, -2…, never overwritten; files already in the destination/library are added in place; sources that can't be removed (read-only card) are kept and reported (`kept`). Undo removes the photos from the library but leaves the moved files at the destination. No Copy as DNG while moving || LR-IMP-DNG-CONVERT | Convert to DNG on import [Classic] | P2 | ✅ | `cmd:library.import` (`dng`), `crates/ui-egui/src/import.rs` | copy imports: Raw files ▸ Copy as DNG (lossless; the card is untouched); the raw copy is removed only once its DNG is verified and on disk (issue #106) |