PSD import: File › Open converts a PSD file's layers to objects

Opening a .psd or .psb used to give one merged image. document.open now reads the layer records and builds the document from them. The PSD import options page (https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-from-other-apps/photoshop-import-options.html) says the option that converts layers to objects keeps as much of the layer structure as it can, merges the layers of a clipping mask into one layer and discards hidden layers that require merging, and that Import Hidden Layers brings hidden layers in. document.open does the same, with hiddenLayers: true for the hidden layers; layers: false keeps the merged image. VectorCraft's own rules: - Each layer becomes a layer holding its pixels as an image, with its name, visibility, opacity and blend mode. A group becomes a layer of sublayers; a Pass Through group is not isolated. - Clipped layers show where the layer below has pixels. That layer's fill opacity fades only its own pixels. Layers clipped to an adjustment layer, or to a fill that stores no pixels and isn't drawn, show over the whole canvas. - A layer mask becomes the layer's opacity mask, its default color and invert flag applied; a disabled mask is kept, switched off. - Fill opacity multiplies the layer's opacity. - Layers and groups in Dissolve, Linear Burn, Linear Dodge, Vivid Light, Linear Light, Pin Light, Hard Mix, Subtract, Divide, Darker Color and Lighter Color are merged with the layers below, whether or not they hold transparent pixels; Color Dodge, Color Burn and Difference keep their mode. A merged Dissolve layer's pixels are opaque or transparent, in a pattern of each layer's own. - A solid color fill layer that stores no pixels and has no vector mask comes in as its color (RGB, CMYK, Grayscale, Lab or HSB). - A layer name stored only as a Pascal string, without its Unicode name, is read as Mac Roman. - Adjustment layers, fill layers that aren't drawn, layer effects that are switched on, knockouts and vector masks are not applied; the warnings count them. - A merge whose canvases need more memory than allowed leaves the layer alone, in the Normal mode or unclipped, with a warning. This changes what opening a layered PSD does. Batch Trace Folder passes layers: false, so a PSD is still traced as its merged image. A file whose layers can't be read, or whose layers and merges need more memory than allowed, opens as the merged image with a warning. Lengths, counts, nesting, decoded pixels and the canvases merges make are bounded. Zipped 32-bit data with prediction is now read, in layers and in the merged image. import_fuzz gains a case that mutates the PSD and PSB samples and opens them with their layers. The PSD reader's new error messages have rows in every catalog. Docs: docs/mcp.md, docs/target-app-parity.md, docs/file-format-parity.md, README.
2026-11-13 09:20:56 -06:00 · 2026-11-11 13:59:32 -08:00
parent 566f720868
commit 0923d862a1
44 changed files with 3048 additions and 118 deletions
@@ -237,7 +237,7 @@ and what's next; [`docs/target-app-parity.md`](docs/target-app-parity.md) the fu
 (92.5% of menu items do something), feature depth is ~75%, and we estimate ~65% ready for real work for a mainstream illustrator (~62% across all tracked features): everyday
 vector illustration is close to usable: drawing and path tools,
 Pathfinder and Shape Builder, paint, gradients, appearance and transparency, type with styles, threading and Hebrew/Arabic bidirectional layout, and
-files (SVG, PDF and PDF-compatible `.ai` with PDF/X, legacy version 7 `.ai` keeping layers, groups and type, EPS, DXF, EMF/WMF, raster formats, PSD out and PSD/PSB in as their merged image, JPEG XL in, Print, Package).
+files (SVG, PDF and PDF-compatible `.ai` with PDF/X, legacy version 7 `.ai` keeping layers, groups and type, EPS, DXF, EMF/WMF, raster formats, PSD out, PSD/PSB opened with their layers and placed as their merged image, JPEG XL in, Print, Package).
 Affinity documents (`.af` from Affinity 3, `.afdesign`, `.afpub` and, by their content, `.afphoto` from Affinity 1 and 2) open
 and place natively: layers, groups, artboards and pages, curves and shapes, fills, gradients and strokes, clipping
 and masks, text with each paragraph's indents, spacing and leading, tables (as text frames and lines), master
@@ -113,7 +113,8 @@ pub(super) fn batch_trace_folder(s: &mut Session, p: &Value) -> Result<Value> {
    for path in &files {
        let opened_before = s.documents().len();
        let one = |s: &mut Session| -> Result<String> {
-            s.execute("document.open", &json!({ "path": path }))?;
+            // A PSD or PSB is traced as its merged image, not as the first of its layers.
+            s.execute("document.open", &json!({ "path": path, "layers": false }))?;
            s.execute("select.all", &json!({}))?;
            s.execute(trace, &json!({ "preset": preset }))?;
            let stem = fileio::file_stem(path);
@@ -333,6 +333,34 @@ fn batch_trace_folder_traces_and_saves_each_image() {
    let _ = std::fs::remove_dir_all(&dir);
 }

+/// A layered PSD is traced as its merged image: a white layer under a black square gives the
+/// square's shape, not a trace of the white layer alone.
+#[cfg(not(target_arch = "wasm32"))]
+#[test]
+fn batch_trace_folder_traces_a_layered_psd_as_its_merged_image() {
+    const C: &str = "addon.document.batchTraceFolder";
+    let dir = folder("batch-trace-psd");
+    let (src, out) = (dir.join("in"), dir.join("out"));
+    std::fs::create_dir_all(&src).unwrap();
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 24, "height": 24})).unwrap();
+    s.execute("paint.setStroke", &json!({"none": true})).unwrap();
+    s.execute("paint.setFill", &json!({"color": "#ffffff"})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 24, "height": 24})).unwrap();
+    s.execute("layer.new", &json!({"name": "Square"})).unwrap();
+    s.execute("select.none", &json!({})).unwrap();
+    s.execute("paint.setFill", &json!({"color": "#000000"})).unwrap();
+    s.execute("shape.rectangle", &json!({"x": 6, "y": 6, "width": 12, "height": 12})).unwrap();
+    let psd = s.execute("document.export", &json!({"format": "psd"})).unwrap();
+    std::fs::write(src.join("two.psd"), vectorcraft_format::base64_decode(psd["dataBase64"].as_str().unwrap()).unwrap()).unwrap();
+    let r =
+        s.execute(C, &json!({"folder": src, "destinationFolder": out, "format": "svg", "preset": "Black and White Logo", "expand": true})).unwrap();
+    assert_eq!(r["traced"].as_array().unwrap().len(), 1, "{r}");
+    let svg = std::fs::read_to_string(out.join("two.svg")).unwrap();
+    assert!(svg.contains("fill=\"#000000\""), "the black square is traced: {svg}");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
 /// Batch Trace Folder rejects optional values with the wrong type before opening images.
 #[cfg(not(target_arch = "wasm32"))]
 #[test]
@@ -50,6 +50,7 @@ mod pdfimport;
 pub mod pngtext;
 pub mod ppi;
 pub mod progress;
+mod psdlayers;
 pub mod psdread;
 mod pxrread;
 mod save;
@@ -218,6 +219,8 @@ mod tests_pdfx;
 #[cfg(test)]
 mod tests_psd;
 #[cfg(test)]
+mod tests_psdlayers;
+#[cfg(test)]
 mod tests_psdread;

 #[cfg(test)]
@@ -493,7 +493,8 @@ pub const FORMATS: &[Format] = &[
    // Affinity Photo's `.afphoto` opens by its content but isn't listed: Finder shouldn't offer a
    // vector app for a raster editor's documents.
    reader("affinity", "Affinity", &["af", "afdesign", "afpub"], "application/x-affinity", false),
-    // Photoshop's large document format: read like a PSD (its merged image), never written.
+    // The large document form of PSD: read like a PSD (its layers, or its merged image), never
+    // written.
    reader("psb", "PSB", &["psb"], "image/x-psb", true),
    // PostScript programs, read as EPS files are; Print to PostScript writes them, exports don't.
    reader("ps", "PostScript", &["ps"], "application/postscript", false),
@@ -492,6 +492,16 @@ pub fn load_with(name: &str, bytes: &[u8], opts: &LoadOptions) -> Result<Loaded>
            preview_only = i.preview_only;
            (i.doc, i.warnings, false)
        }
+        // A PSD or PSB file's layers become layers (`layers`, default on); without layers, or with
+        // `layers: false`, its merged image opens. Layers that can't be read leave the merged image.
+        "psd" | "psb" if opts.layers => {
+            let cms = vectorcraft_color::cms::active();
+            match super::psdlayers::import(bytes, opts.hidden_layers, MAX_RASTER_ALLOC, |c| cms.cmyk_to_srgb(c, false)) {
+                Ok(Some((doc, warnings))) => (doc, warnings, false),
+                Ok(None) => (raster_doc(&title, bytes)?, vec![], false),
+                Err(e) => (raster_doc(&title, bytes)?, vec![format!("the layers can't be read ({e}): the file opened as its merged image")], false),
+            }
+        }
        _ if format.raster => (raster_doc(&title, bytes)?, vec![], false),
        _ => return Err(err(format!("{} files can't be opened yet", format.label))),
    };
@@ -28,8 +28,10 @@ pub struct LoadOptions {
    /// What a PDF's text becomes.
    pub text_as: TextAs,
    /// A PDF's optional content groups become layers (else one layer per page, without the art
-    /// that is off).
+    /// that is off), and a PSD or PSB file's layers become layers (else its merged image opens).
    pub layers: bool,
+    /// A PSD or PSB file's hidden layers come in, hidden (`hiddenLayers`; else they are left out).
+    pub hidden_layers: bool,
    /// How a DXF drawing comes in (the `dxf` param, see [`super::dxfimport`]).
    pub dxf: vectorcraft_cad::ImportOptions,
    /// An Illustrator EPS or `.ai` that carries the editing copy of its art opens from it (its
@@ -57,6 +59,7 @@ impl Default for LoadOptions {
            grays: Grays::default(),
            text_as: TextAs::default(),
            layers: true,
+            hidden_layers: false,
            dxf: Default::default(),
            editing_data: true,
            trust_editing_data: false,
@@ -69,7 +72,8 @@ impl Default for LoadOptions {
 impl LoadOptions {
    /// From command params: `pages` (`"2-3, 5"`, a page number or `"all"`), `page` (one page, when
    /// `pages` isn't given), `cropTo` (or `crop`), `password`, `colorMode` (`rgb` | `cmyk`) with `grays`,
-    /// `textAs` (`text` | `outlines`), `layers` (true | false), `editingData` (true | false | `always`),
+    /// `textAs` (`text` | `outlines`), `layers` (true | false), `hiddenLayers` (true | false),
+    /// `editingData` (true | false | `always`),
    /// `legacyNameEncoding` (one of [`vectorcraft_eps::NameEncoding::LABELS`]) and `dxf` (the DXF
    /// import options).
    pub fn from_params(cmd: &str, p: &Value) -> Result<Self> {
@@ -95,6 +99,10 @@ impl LoadOptions {
            None => true,
            Some(v) => v.as_bool().ok_or_else(|| bad(cmd, "layers must be true or false"))?,
        };
+        let hidden_layers = match p.get("hiddenLayers").filter(|v| !v.is_null()) {
+            None => false,
+            Some(v) => v.as_bool().ok_or_else(|| bad(cmd, "hiddenLayers must be true or false"))?,
+        };
        let (editing_data, trust_editing_data) = match p.get("editingData").filter(|v| !v.is_null()) {
            None => (true, false),
            Some(Value::String(s)) if s.eq_ignore_ascii_case("always") => (true, true),
@@ -108,7 +116,21 @@ impl LoadOptions {
                .ok_or_else(|| bad(cmd, format!("legacyNameEncoding must be one of {}", vectorcraft_eps::NameEncoding::LABELS.join(", "))))?,
        };
        let dxf = super::dxfimport::options(cmd, p.get("dxf"))?;
-        Ok(Self { pages, crop, password, color_mode, grays, text_as, layers, dxf, editing_data, trust_editing_data, legacy_names, native: true })
+        Ok(Self {
+            pages,
+            crop,
+            password,
+            color_mode,
+            grays,
+            text_as,
+            layers,
+            hidden_layers,
+            dxf,
+            editing_data,
+            trust_editing_data,
+            legacy_names,
+            native: true,
+        })
    }

    /// Does the document read only part of the file, or read it differently (a page range, another
@@ -1,7 +1,8 @@
 //! Reading Photoshop documents (PSD, and PSB, the large document format) for File › Open and
 //! File › Place (#918): the merged image, the flattened picture every PSD carries after its layers,
 //! as a linked PSD shows. Written from Adobe's public "Photoshop File Formats Specification"
-//! (<https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/>). Layers aren't read.
+//! (<https://www.adobe.com/devnet-apps/photoshop/fileformatashtml/>). File › Open reads the
+//! layers with [`super::psdlayers`], which shares this reader.
 //!
 //! Every mode Photoshop saves a merged image in is read: Bitmap, Grayscale, Duotone (as its
 //! grayscale data), Indexed, RGB, CMYK and Lab, at 1, 8, 16 and 32 bits per channel, stored raw,
@@ -16,7 +17,7 @@ use vectorcraft_color::cms::{Lab, lab::lab_to_srgb};

 /// Photoshop's colour modes (the header's numbers), as far as the merged image is concerned.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
-enum Mode {
+pub(super) enum Mode {
    Bitmap,
    Gray,
    Indexed,
@@ -27,7 +28,7 @@ enum Mode {

 impl Mode {
    /// The channels holding colour (an alpha channel may follow them).
-    fn colors(self) -> usize {
+    pub(super) fn colors(self) -> usize {
        match self {
            Mode::Bitmap | Mode::Gray | Mode::Indexed => 1,
            Mode::Rgb | Mode::Lab => 3,
@@ -46,68 +47,68 @@ pub fn is_psb(bytes: &[u8]) -> bool {
    is_psd(bytes) && bytes.get(4..6) == Some(&[0, 2])
 }

-const TRUNCATED: &str = "the PSD file is cut short";
+pub(super) const TRUNCATED: &str = "the PSD file is cut short";
 const DAMAGED: &str = "the PSD file's header is damaged";

 /// Big-endian reads through `b`, each checked against its end.
-struct Reader<'a> {
+pub(super) struct Reader<'a> {
    b: &'a [u8],
    at: usize,
 }

 impl<'a> Reader<'a> {
-    fn new(b: &'a [u8]) -> Self {
+    pub(super) fn new(b: &'a [u8]) -> Self {
        Self { b, at: 0 }
    }
-    fn take(&mut self, n: usize) -> Result<&'a [u8], String> {
+    pub(super) fn take(&mut self, n: usize) -> Result<&'a [u8], String> {
        let s = self.at.checked_add(n).and_then(|end| self.b.get(self.at..end)).ok_or(TRUNCATED)?;
        self.at += n;
        Ok(s)
    }
-    fn array<const N: usize>(&mut self) -> Result<[u8; N], String> {
+    pub(super) fn array<const N: usize>(&mut self) -> Result<[u8; N], String> {
        self.take(N)?.try_into().map_err(|_| TRUNCATED.to_string())
    }
-    fn u8(&mut self) -> Result<u8, String> {
+    pub(super) fn u8(&mut self) -> Result<u8, String> {
        self.array::<1>().map(|[v]| v)
    }
-    fn u16(&mut self) -> Result<u16, String> {
+    pub(super) fn u16(&mut self) -> Result<u16, String> {
        self.array().map(u16::from_be_bytes)
    }
-    fn u32(&mut self) -> Result<u32, String> {
+    pub(super) fn u32(&mut self) -> Result<u32, String> {
        self.array().map(u32::from_be_bytes)
    }
    /// A section length: 4 bytes in a PSD, 8 in a PSB.
-    fn length(&mut self, psb: bool) -> Result<usize, String> {
+    pub(super) fn length(&mut self, psb: bool) -> Result<usize, String> {
        let n = if psb { self.array().map(u64::from_be_bytes)? } else { u64::from(self.u32()?) };
        usize::try_from(n).map_err(|_| TRUNCATED.to_string())
    }
    /// A section: its length, then that many bytes.
-    fn section(&mut self, psb: bool) -> Result<&'a [u8], String> {
+    pub(super) fn section(&mut self, psb: bool) -> Result<&'a [u8], String> {
        let n = self.length(psb)?;
        self.take(n)
    }
-    fn rest(&self) -> &'a [u8] {
+    pub(super) fn rest(&self) -> &'a [u8] {
        self.b.get(self.at..).unwrap_or_default()
    }
 }

 /// The fixed-size header and the sections before the image data.
-struct Header<'a> {
-    psb: bool,
+pub(super) struct Header<'a> {
+    pub(super) psb: bool,
    channels: usize,
-    width: u32,
-    height: u32,
-    depth: u16,
-    mode: Mode,
+    pub(super) width: u32,
+    pub(super) height: u32,
+    pub(super) depth: u16,
+    pub(super) mode: Mode,
    /// Colour mode data: an indexed image's palette (256 reds, then greens, then blues).
    palette: &'a [u8],
    /// The image resources.
    resources: &'a [u8],
    /// The layer and mask information.
-    layers: &'a [u8],
+    pub(super) layers: &'a [u8],
 }

-fn header<'a>(r: &mut Reader<'a>) -> Result<Header<'a>, String> {
+pub(super) fn header<'a>(r: &mut Reader<'a>) -> Result<Header<'a>, String> {
    if !is_psd(r.b) {
        return Err("not a PSD file".into());
    }
@@ -183,41 +184,45 @@ pub fn resolution(bytes: &[u8]) -> Option<(f64, f64)> {
 /// count is negative: in the layer info, or for 16- and 32-bit documents (whose layer info is
 /// empty) in their `Lr16` / `Lr32` block.
 fn merged_alpha(layers: &[u8], psb: bool) -> bool {
-    let count_negative = |info: &[u8]| info.get(..2).is_some_and(|c| i16::from_be_bytes([c[0], c[1]]) < 0);
+    layer_info(layers, psb).is_some_and(|info| info.get(..2).is_some_and(|c| i16::from_be_bytes([c[0], c[1]]) < 0))
+}
+
+/// Do tagged blocks with this key give an 8-byte length in a PSB?
+pub(super) fn long_key(key: &[u8; 4]) -> bool {
+    matches!(key, b"Lr16" | b"Lr32" | b"Layr" | b"LMsk" | b"Mt16" | b"Mt32" | b"Mtrn" | b"Alph" | b"FMsk" | b"lnk2" | b"FEid" | b"FXid" | b"PxSD")
+}
+
+/// The layer info: the layer count, the layer records and their channels. It is the first part of
+/// the layer and mask information, or for 16- and 32-bit documents (whose first part is empty) the
+/// `Lr16` / `Lr32` block after it. `None` when the file has neither.
+pub(super) fn layer_info(layers: &[u8], psb: bool) -> Option<&[u8]> {
    let mut r = Reader::new(layers);
-    let Ok(info) = r.section(psb) else { return false };
+    let info = r.section(psb).ok()?;
    if !info.is_empty() {
-        return count_negative(info);
+        return Some(info);
    }
    // The global layer mask info, then tagged blocks: signature, key, length (8 bytes for the
    // layer blocks of a PSB), data padded to 4 bytes.
-    if r.section(false).is_err() {
-        return false;
-    }
+    r.section(false).ok()?;
    while r.rest().len() >= 12 {
-        let (Ok(_), Ok(key)) = (r.take(4), r.array::<4>()) else { return false };
-        let layer_block = matches!(&key, b"Lr16" | b"Lr32" | b"Layr");
-        let long = layer_block || matches!(&key, b"LMsk" | b"Mt16" | b"Mt32" | b"Mtrn" | b"Alph" | b"FMsk" | b"lnk2" | b"FEid" | b"FXid" | b"PxSD");
-        let Ok(data) = r.section(psb && long) else {
-            return false;
-        };
-        if layer_block {
-            return count_negative(data);
-        }
-        if r.take((4 - data.len() % 4) % 4).is_err() {
-            return false;
+        r.take(4).ok()?;
+        let key = r.array::<4>().ok()?;
+        let data = r.section(psb && long_key(&key)).ok()?;
+        if matches!(&key, b"Lr16" | b"Lr32" | b"Layr") {
+            return Some(data);
        }
+        r.take((4 - data.len() % 4) % 4).ok()?;
    }
-    false
+    None
 }

 /// The most bytes one channel row may take (a PSB at 32 bits).
-fn row_bytes(width: usize, depth: u16) -> usize {
+pub(super) fn row_bytes(width: usize, depth: u16) -> usize {
    if depth == 1 { width.div_ceil(8) } else { width * usize::from(depth / 8) }
 }

 /// Undo PackBits: `src` into `dst` (a row; a short or overlong run leaves the rest as it is).
-fn unpack_bits(mut src: &[u8], dst: &mut [u8]) {
+pub(super) fn unpack_bits(mut src: &[u8], dst: &mut [u8]) {
    let mut at = 0;
    while let Some((&n, rest)) = src.split_first() {
        src = rest;
@@ -269,32 +274,77 @@ fn channel_data(data: &[u8], h: &Header<'_>, channels: usize, row: usize) -> Res
            }
            Ok(out)
        }
-        2 | 3 => {
-            let mut out = Vec::new();
-            flate2::read::ZlibDecoder::new(r.rest())
-                .take(wanted as u64)
-                .read_to_end(&mut out)
-                .map_err(|e| format!("the PSD file's image data can't be read: {e}"))?;
-            if out.len() < wanted {
-                return Err(TRUNCATED.into());
-            }
-            if method == 3 {
-                // Each row stores the difference from the sample before it.
-                match h.depth {
-                    8 => out.chunks_exact_mut(row).for_each(|r| (1..r.len()).for_each(|i| r[i] = r[i].wrapping_add(r[i - 1]))),
-                    16 => out.chunks_exact_mut(row).for_each(|r| {
-                        let mut prev = 0u16;
-                        for s in r.as_chunks_mut::<2>().0 {
-                            prev = prev.wrapping_add(u16::from_be_bytes(*s));
-                            *s = prev.to_be_bytes();
-                        }
-                    }),
-                    _ => return Err("zipped 32-bit PSD image data with prediction can't be read".into()),
+        2 | 3 => inflate(r.rest(), wanted, method == 3, h.depth, row),
+        m => Err(format!("the PSD file's image data uses an unknown compression ({m})")),
+    }
+}
+
+/// `wanted` bytes of zipped image data, rows of `row` bytes; with `predicted`, each row stores the
+/// difference from the sample before it. In 32-bit data a row stores the first bytes of its samples,
+/// then their second bytes, and so on, and the differences run byte by byte along the whole row (as
+/// psd-tools, MIT, reads it: <https://github.com/psd-tools/psd-tools>, `compression/__init__.py`).
+fn inflate(src: &[u8], wanted: usize, predicted: bool, depth: u16, row: usize) -> Result<Vec<u8>, String> {
+    let mut out = Vec::new();
+    flate2::read::ZlibDecoder::new(src)
+        .take(wanted as u64)
+        .read_to_end(&mut out)
+        .map_err(|e| format!("the PSD file's image data can't be read: {e}"))?;
+    if out.len() < wanted {
+        return Err(TRUNCATED.into());
+    }
+    if predicted && row > 0 {
+        match depth {
+            8 => out.chunks_exact_mut(row).for_each(|r| (1..r.len()).for_each(|i| r[i] = r[i].wrapping_add(r[i - 1]))),
+            16 => out.chunks_exact_mut(row).for_each(|r| {
+                let mut prev = 0u16;
+                for s in r.as_chunks_mut::<2>().0 {
+                    prev = prev.wrapping_add(u16::from_be_bytes(*s));
+                    *s = prev.to_be_bytes();
                }
+            }),
+            32 => {
+                let w = row / 4;
+                let mut planes = vec![0u8; row];
+                for r in out.chunks_exact_mut(row) {
+                    let mut prev = 0u8;
+                    for (dst, &b) in planes.iter_mut().zip(r.iter()) {
+                        prev = prev.wrapping_add(b);
+                        *dst = prev;
+                    }
+                    for (x, s) in r.as_chunks_mut::<4>().0.iter_mut().enumerate() {
+                        for (k, v) in s.iter_mut().enumerate() {
+                            *v = planes.get(k * w + x).copied().unwrap_or(0);
+                        }
+                    }
+                }
+            }
+            // 1-bit.
+            _ => return Err("zipped 1-bit PSD image data with prediction can't be read".into()),
+        }
+    }
+    Ok(out)
+}
+
+/// One channel of a layer: its compression method, then `rows` rows of `row` bytes (PackBits rows
+/// after their byte counts, 4 bytes each in a PSB).
+pub(super) fn layer_channel(data: &[u8], rows: usize, row: usize, psb: bool, depth: u16) -> Result<Vec<u8>, String> {
+    let mut r = Reader::new(data);
+    let method = r.u16()?;
+    let wanted = rows.checked_mul(row).ok_or(TRUNCATED)?;
+    match method {
+        0 => r.take(wanted).map(<[u8]>::to_vec),
+        1 => {
+            let size = if psb { 4 } else { 2 };
+            let counts = r.take(rows.checked_mul(size).ok_or(TRUNCATED)?)?;
+            let mut out = vec![0; wanted];
+            for (dst, n) in out.chunks_exact_mut(row.max(1)).zip(counts.chunks_exact(size)) {
+                let n = n.iter().fold(0usize, |n, &b| n << 8 | usize::from(b));
+                unpack_bits(r.take(n)?, dst);
            }
            Ok(out)
        }
-        m => Err(format!("the PSD file's image data uses an unknown compression ({m})")),
+        2 | 3 => inflate(r.rest(), wanted, method == 3, depth, row),
+        m => Err(format!("the PSD file's layer data uses an unknown compression ({m})")),
    }
 }

@@ -304,7 +354,7 @@ fn srgb_encode(v: f32) -> f32 {
 }

 /// Sample `x` of a channel row, 0..1.
-fn sample(row: &[u8], x: usize, depth: u16, linear: bool) -> f32 {
+pub(super) fn sample(row: &[u8], x: usize, depth: u16, linear: bool) -> f32 {
    match depth {
        1 => {
            // Bitmap: a set bit is black.
@@ -321,10 +371,25 @@ fn sample(row: &[u8], x: usize, depth: u16, linear: bool) -> f32 {
    }
 }

-fn byte(v: f32) -> u8 {
+pub(super) fn byte(v: f32) -> u8 {
    (v.clamp(0.0, 1.0) * 255.0).round() as u8
 }

+/// The sRGB color of a pixel whose color channels `v` gives (0..1, as stored), in `h`'s mode.
+pub(super) fn to_rgb(h: &Header<'_>, v: impl Fn(usize) -> f32, cmyk: &impl Fn([f32; 4]) -> [f32; 3]) -> [f32; 3] {
+    match h.mode {
+        Mode::Bitmap | Mode::Gray => [v(0); 3],
+        Mode::Indexed => {
+            let i = usize::from(byte(v(0)));
+            [0, 256, 512].map(|at| h.palette.get(at + i).map_or(0.0, |&c| f32::from(c) / 255.0))
+        }
+        Mode::Rgb => [v(0), v(1), v(2)],
+        // Inks are stored as 1 − amount.
+        Mode::Cmyk => cmyk([0, 1, 2, 3].map(|c| 1.0 - v(c))),
+        Mode::Lab => lab_to_srgb(Lab { l: v(0) * 100.0, a: v(1) * 255.0 - 128.0, b: v(2) * 255.0 - 128.0 }),
+    }
+}
+
 /// A Photoshop document's merged image as straight RGBA. CMYK converts through `cmyk` (ink
 /// amounts 0..1 → sRGB). Fails, without allocating, when the image would need more than
 /// `max_alloc` bytes.
@@ -348,17 +413,7 @@ pub fn decode(bytes: &[u8], max_alloc: u64, cmyk: impl Fn([f32; 4]) -> [f32; 3])
        let planes: Vec<&[u8]> = (0..channels).map(|c| data.get((c * rows + y) * row..(c * rows + y + 1) * row).unwrap_or_default()).collect();
        for (x, px) in line.enumerate() {
            let v = |c: usize| planes.get(c).map_or(0.0, |p| sample(p, x, h.depth, linear && c < colors));
-            let rgb = match h.mode {
-                Mode::Bitmap | Mode::Gray => [v(0); 3],
-                Mode::Indexed => {
-                    let i = usize::from(byte(v(0)));
-                    [0, 256, 512].map(|at| h.palette.get(at + i).map_or(0.0, |&c| f32::from(c) / 255.0))
-                }
-                Mode::Rgb => [v(0), v(1), v(2)],
-                // Inks are stored as 1 − amount.
-                Mode::Cmyk => cmyk([0, 1, 2, 3].map(|c| 1.0 - v(c))),
-                Mode::Lab => lab_to_srgb(Lab { l: v(0) * 100.0, a: v(1) * 255.0 - 128.0, b: v(2) * 255.0 - 128.0 }),
-            };
+            let rgb = to_rgb(&h, v, &cmyk);
            let a = if alpha { v(colors) } else { 1.0 };
            // The merged image is stored on white: take the white back out.
            let straight = |c: f32| if a <= 0.0 { 0.0 } else { (c - (1.0 - a)) / a };
@@ -141,6 +141,31 @@ fn packbits_zip_and_psb_files_read() {
    zip.extend(z.finish().unwrap());
    let px = pixels(&psd(1, 1, (3, 1), 16, 1, &[], &[], &[], &zip));
    assert_eq!(px.iter().map(|p| p[0]).collect::<Vec<_>>(), [16, 32, 48]);
+    // Zipped with prediction, 32 bits: the row's first bytes, then its second bytes and so on,
+    // each byte stored as the difference from the byte before it.
+    let samples = [0.0f32, 1.0, 0.0].map(f32::to_be_bytes);
+    let planes: Vec<u8> = (0..4).flat_map(|k| samples.iter().map(move |s| s[k])).collect();
+    let deltas: Vec<u8> = planes.iter().scan(0u8, |prev, &b| Some(b.wrapping_sub(std::mem::replace(prev, b)))).collect();
+    let mut z = flate2::write::ZlibEncoder::new(Vec::new(), flate2::Compression::default());
+    std::io::Write::write_all(&mut z, &deltas).unwrap();
+    let mut zip = vec![0, 3];
+    zip.extend(z.finish().unwrap());
+    let px = pixels(&psd(1, 1, (3, 1), 32, 1, &[], &[], &[], &zip));
+    assert_eq!(px.iter().map(|p| p[0]).collect::<Vec<_>>(), [0, 255, 0]);
+    // The same layout as another implementation writes it: psd-tools 1.26.1 (MIT,
+    // <https://github.com/psd-tools/psd-tools>), `compression.compress(data,
+    // Compression.ZIP_WITH_PREDICTION, 3, 2, 32)` of the samples 0, 1, 0.25 and 0.5, 0.125, 1,
+    // reads as the same samples stored raw.
+    let theirs = [
+        0x78, 0x9c, 0x63, 0xb0, 0xff, 0x7f, 0xa8, 0x81, 0xa1, 0x81, 0x01, 0x04, 0xec, 0xff, 0x33, 0x1e, 0x64, 0x68, 0x80, 0xb0, 0x01, 0x59, 0xd1,
+        0x06, 0x01,
+    ];
+    let mut zip = vec![0, 3];
+    zip.extend(theirs);
+    let samples: Vec<u8> = [0.0f32, 1.0, 0.25, 0.5, 0.125, 1.0].iter().flat_map(|v| v.to_be_bytes()).collect();
+    let stored = pixels(&psd(1, 1, (3, 2), 32, 1, &[], &[], &[], &raw(&[&samples])));
+    assert_eq!(pixels(&psd(1, 1, (3, 2), 32, 1, &[], &[], &[], &zip)), stored);
+    assert_eq!(stored.iter().map(|p| p[0]).collect::<Vec<_>>()[..2], [0, 255]);
 }

 #[test]
@@ -108,7 +108,7 @@ pub(in crate::cmd) fn windows_1252(b: u8) -> char {
 }

 /// Byte `b` of Mac Roman.
-pub(super) fn mac_roman(b: u8) -> char {
+pub(in crate::cmd) fn mac_roman(b: u8) -> char {
    const HIGH: [char; 128] = [
        'Ä', 'Å', 'Ç', 'É', 'Ñ', 'Ö', 'Ü', 'á', 'à', 'â', 'ä', 'ã', 'å', 'ç', 'é', 'è', //
        'ê', 'ë', 'í', 'ì', 'î', 'ï', 'ñ', 'ó', 'ò', 'ô', 'ö', 'õ', 'ú', 'ù', 'û', 'ü', //
@@ -1807,6 +1807,27 @@ proptest! {
        });
        prop_assert!(r.is_ok(), "{name}: panicked: {:?}", r.err());
    }
+
+    /// Mutated copies of the PSD and PSB samples never crash opening them with their layers, hidden
+    /// ones too: the PSD's layer records, channel lengths and data, and the PSB's layer count.
+    /// (Masks, clipping and groups are covered by `tests_psdlayers::damaged_layers_never_panic`.)
+    #[test]
+    fn mutated_layered_psds_open_without_panics(which in 6usize..8, cut in 0usize..1_000_000, edits in prop::collection::vec((0usize..1_000_000, any::<u8>()), 0..12)) {
+        let (name, mut bytes) = raster_samples().swap_remove(which);
+        let len = bytes.len();
+        for (at, b) in edits {
+            if let Some(x) = bytes.get_mut(at % len) {
+                *x = b;
+            }
+        }
+        bytes.truncate((cut % (len + 1)).max(8));
+        let r = catch_quiet(|| {
+            let mut s = vectorcraft_engine::Session::new();
+            let p = json!({"name": name, "dataBase64": vectorcraft_format::base64_encode(&bytes), "hiddenLayers": true});
+            let _ = no_panic(s.execute("document.open", &p));
+        });
+        prop_assert!(r.is_ok(), "{name}: panicked: {:?}", r.err());
+    }
 }

 /// 1-bit TIFFs compressed with CCITT Group 3: modified Huffman (Compression 2) in three strips, T.4
@@ -4775,7 +4775,13 @@ axis	Both	И двете
@msg	the PSD file has an unknown colour mode ({m})	PSD файлът има непознат цветови режим ({m})
@msg	the PSD file's image data uses an unknown compression ({m})	образните данни на PSD файла използват непознато компресиране ({m})
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	PSD изображението е твърде голямо за четене ({_1} × {_2} пиксела)
-@msg	zipped 32-bit PSD image data with prediction can't be read	архивирани (zipped) 32-битови PSD образни данни с предсказване не могат да бъдат прочетени
+@msg	zipped 1-bit PSD image data with prediction can't be read	архивирани (zipped) 1-битови PSD образни данни с предсказване не могат да бъдат прочетени
+@msg	the PSD file's layer data uses an unknown compression ({m})	данните на слоевете на PSD файла използват непознато компресиране ({m})
+@msg	the PSD file's layer records are damaged	записите на слоевете на PSD файла са повредени
+@msg	the PSD file's layer groups are nested too deeply	групите слоеве на PSD файла са вложени твърде дълбоко
+@msg	a layer of the PSD file is too large to read	слой на PSD файла е твърде голям за четене
+@msg	the PSD file's layers take more memory to read than allowed	слоевете на PSD файла изискват повече памет за четене от позволеното
+@msg	the layers can't be read ({e}): the file opened as its merged image	слоевете не могат да бъдат прочетени ({e}): файлът е отворен като обединеното си изображение
@msg	{depth}-bit PSD files in this colour mode can't be read	{depth}-битови PSD файлове в този цветови режим не могат да бъдат прочетени
@msg	the PSD file is cut short	PSD файлът е непълен
@msg	the PSD file's header is damaged	заглавната част (header) на PSD файла е повредена
@@ -5143,7 +5143,13 @@ imageTrace	Outline	Obris
@msg	the HEIC or HEIF file holds a kind of image that can't be read	datoteka HEIC ili HEIF sadrži vrstu slike koju nije moguće pročitati
@msg	HEIC and HEIF images can't be opened in this build	HEIC i HEIF slike nije moguće otvoriti u ovoj verziji programa
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	PSD slika je prevelika za čitanje ({_1} × {_2} piksela)
-@msg	zipped 32-bit PSD image data with prediction can't be read	zipovani 32-bitni PSD podaci slike s predviđanjem ne mogu se pročitati
+@msg	zipped 1-bit PSD image data with prediction can't be read	zipovani 1-bitni PSD podaci slike s predviđanjem ne mogu se pročitati
+@msg	the PSD file's layer data uses an unknown compression ({m})	podaci slojeva PSD datoteke koriste nepoznatu kompresiju ({m})
+@msg	the PSD file's layer records are damaged	zapisi slojeva PSD datoteke su oštećeni
+@msg	the PSD file's layer groups are nested too deeply	grupe slojeva PSD datoteke su previše duboko ugniježđene
+@msg	a layer of the PSD file is too large to read	sloj PSD datoteke je prevelik za čitanje
+@msg	the PSD file's layers take more memory to read than allowed	slojevi PSD datoteke zahtijevaju više memorije za čitanje nego što je dozvoljeno
+@msg	the layers can't be read ({e}): the file opened as its merged image	slojevi se ne mogu pročitati ({e}): datoteka je otvorena kao spojena slika
@msg	{depth}-bit PSD files in this colour mode can't be read	{depth}-bitne PSD datoteke u ovom načinu boja ne mogu se pročitati
@msg	the PSD file is cut short	PSD datoteka je skraćena
@msg	the PSD file's header is damaged	zaglavlje PSD datoteke je oštećeno
@@ -6001,7 +6001,13 @@ digits	Malayalam	Malaiàlam
@msg	x and y must be provided together	cal proporcionar x i y alhora
@msg	x and y must both be numbers	x i y han de ser tots dos nombres
@msg	Your unsaved changes are kept in this browser: reload the page to get them back.	Els canvis no desats es conserven en aquest navegador: torna a carregar la pàgina per recuperar-los.
-@msg	zipped 32-bit PSD image data with prediction can't be read	les dades d’imatge PSD de 32 bits comprimides amb predicció no es poden llegir
+@msg	zipped 1-bit PSD image data with prediction can't be read	les dades d’imatge PSD d’1 bit comprimides amb predicció no es poden llegir
+@msg	the PSD file's layer data uses an unknown compression ({m})	les dades de capa del fitxer PSD utilitzen una compressió desconeguda ({m})
+@msg	the PSD file's layer records are damaged	els registres de capes del fitxer PSD estan malmesos
+@msg	the PSD file's layer groups are nested too deeply	els grups de capes del fitxer PSD estan imbricats massa profundament
+@msg	a layer of the PSD file is too large to read	una capa del fitxer PSD és massa gran per llegir-la
+@msg	the PSD file's layers take more memory to read than allowed	les capes del fitxer PSD necessiten més memòria de la permesa per llegir-les
+@msg	the layers can't be read ({e}): the file opened as its merged image	no es poden llegir les capes ({e}): el fitxer s’ha obert com a imatge combinada
@msg	zone must be a string	zone ha de ser una cadena
@msg	zone must be tab, center, left, right, top or bottom	zone ha de ser tab, center, left, right, top o bottom
@msg	{_1} failed: {e}	{_1} ha fallat: {e}
@@ -5241,7 +5241,13 @@ imageTrace	Outline	Obrys
@msg	the HEIC or HEIF file holds a kind of image that can't be read	soubor HEIC nebo HEIF obsahuje druh obrázku, který nelze přečíst
@msg	HEIC and HEIF images can't be opened in this build	obrázky HEIC a HEIF nelze v tomto sestavení otevřít
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	obraz PSD je příliš velký na přečtení ({_1} × {_2} obrazových bodů)
-@msg	zipped 32-bit PSD image data with prediction can't be read	zazipovaná 32bitová obrazová data PSD s predikcí nelze přečíst
+@msg	zipped 1-bit PSD image data with prediction can't be read	zazipovaná 1bitová obrazová data PSD s predikcí nelze přečíst
+@msg	the PSD file's layer data uses an unknown compression ({m})	data vrstev souboru PSD používají neznámou kompresi ({m})
+@msg	the PSD file's layer records are damaged	záznamy vrstev souboru PSD jsou poškozené
+@msg	the PSD file's layer groups are nested too deeply	skupiny vrstev souboru PSD jsou vnořené příliš hluboko
+@msg	a layer of the PSD file is too large to read	vrstva souboru PSD je příliš velká na přečtení
+@msg	the PSD file's layers take more memory to read than allowed	vrstvy souboru PSD potřebují ke čtení víc paměti, než je povoleno
+@msg	the layers can't be read ({e}): the file opened as its merged image	vrstvy nelze přečíst ({e}): soubor se otevřel jako sloučený obraz
@msg	{depth}-bit PSD files in this colour mode can't be read	{depth}bitové soubory PSD v tomto barevném režimu nelze přečíst
@msg	the PSD file is cut short	soubor PSD je useknutý
@msg	the PSD file's header is damaged	hlavička souboru PSD je poškozená
@@ -4822,7 +4822,13 @@ imageTrace	Outline	Kontur
@msg	the PSD file has an unknown colour mode ({m})	PSD-filen har en ukendt farvetilstand ({m})
@msg	the PSD file's image data uses an unknown compression ({m})	PSD-filens billeddata bruger en ukendt komprimering ({m})
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	PSD-billedet er for stort til at læse ({_1} × {_2} pixels)
-@msg	zipped 32-bit PSD image data with prediction can't be read	zippet 32-bit PSD-billeddata med prædiktion kan ikke læses
+@msg	zipped 1-bit PSD image data with prediction can't be read	zippet 1-bit PSD-billeddata med prædiktion kan ikke læses
+@msg	the PSD file's layer data uses an unknown compression ({m})	PSD-filens lagdata bruger en ukendt komprimering ({m})
+@msg	the PSD file's layer records are damaged	PSD-filens lagposter er beskadigede
+@msg	the PSD file's layer groups are nested too deeply	PSD-filens laggrupper er indlejret for dybt
+@msg	a layer of the PSD file is too large to read	et lag i PSD-filen er for stort til at læse
+@msg	the PSD file's layers take more memory to read than allowed	PSD-filens lag kræver mere hukommelse at læse end tilladt
+@msg	the layers can't be read ({e}): the file opened as its merged image	lagene kan ikke læses ({e}): filen blev åbnet som sit samlede billede
@msg	{depth}-bit PSD files in this colour mode can't be read	{depth}-bit PSD-filer i denne farvetilstand kan ikke læses
@msg	the PSD file is cut short	PSD-filen er afkortet
@msg	the PSD file's header is damaged	PSD-filens header er beskadiget
@@ -4964,7 +4964,7 @@ theme	Appearance	Erscheinungsbild
 	The key color becomes the stroke color. The other colors shift their hue by the same amount and keep their saturation and brightness.	Die Hauptfarbe wird zur Konturfarbe. Die anderen Farben wandern ebenso weit um den Farbkreis wie die Hauptfarbe und behalten ihre Sättigung und Helligkeit.
 	RGB:	RGB:
 	CMYK:	CMYK:
-# PSD files (opened and placed as their merged image).
+# PSD files.
@msg	not a PSD file	keine PSD-Datei
@msg	Multichannel PSD files can't be read: save it in RGB, CMYK or Grayscale mode	PSD-Dateien im Mehrkanalmodus können nicht gelesen werden: Speichern Sie die Datei im RGB-, CMYK- oder Graustufenmodus
@msg	the PSD file has an unknown colour mode ({m})	die PSD-Datei hat einen unbekannten Farbmodus ({m})
@@ -4984,7 +4984,13 @@ theme	Appearance	Erscheinungsbild
@msg	the HEIC or HEIF file holds a kind of image that can't be read	die HEIC- oder HEIF-Datei enthält eine Bildart, die nicht gelesen werden kann
@msg	HEIC and HEIF images can't be opened in this build	HEIC- und HEIF-Bilder können in diesem Build nicht geöffnet werden
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	das PSD-Bild ist zu groß zum Lesen ({_1} × {_2} Pixel)
-@msg	zipped 32-bit PSD image data with prediction can't be read	ZIP-komprimierte 32-Bit-PSD-Bilddaten mit Vorhersage können nicht gelesen werden
+@msg	zipped 1-bit PSD image data with prediction can't be read	ZIP-komprimierte 1-Bit-PSD-Bilddaten mit Vorhersage können nicht gelesen werden
+@msg	the PSD file's layer data uses an unknown compression ({m})	die Ebenendaten der PSD-Datei verwenden eine unbekannte Komprimierung ({m})
+@msg	the PSD file's layer records are damaged	die Ebenendatensätze der PSD-Datei sind beschädigt
+@msg	the PSD file's layer groups are nested too deeply	die Ebenengruppen der PSD-Datei sind zu tief verschachtelt
+@msg	a layer of the PSD file is too large to read	eine Ebene der PSD-Datei ist zu groß zum Lesen
+@msg	the PSD file's layers take more memory to read than allowed	die Ebenen der PSD-Datei brauchen zum Lesen mehr Speicher als erlaubt
+@msg	the layers can't be read ({e}): the file opened as its merged image	die Ebenen können nicht gelesen werden ({e}): die Datei wurde als ihr zusammengefügtes Bild geöffnet
@msg	{depth}-bit PSD files in this colour mode can't be read	{depth}-Bit-PSD-Dateien in diesem Farbmodus können nicht gelesen werden
@msg	the JPEG XL file is cut short	die JPEG-XL-Datei ist unvollständig
@msg	the JPEG XL container is too large to read	der JPEG-XL-Container ist zu groß zum Lesen
@@ -4920,7 +4920,13 @@ digits	Malayalam	Μαλαγιάλαμ
@msg	the HEIC or HEIF file holds a kind of image that can't be read	το αρχείο HEIC ή HEIF περιέχει είδος εικόνας που δεν είναι δυνατό να διαβαστεί
@msg	HEIC and HEIF images can't be opened in this build	οι εικόνες HEIC και HEIF δεν μπορούν να ανοίξουν σε αυτή την έκδοση
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	η εικόνα PSD είναι πολύ μεγάλη για ανάγνωση ({_1} × {_2} εικονοστοιχεία)
-@msg	zipped 32-bit PSD image data with prediction can't be read	τα συμπιεσμένα δεδομένα εικόνας PSD 32 bit με πρόβλεψη δεν διαβάζονται
+@msg	zipped 1-bit PSD image data with prediction can't be read	τα συμπιεσμένα δεδομένα εικόνας PSD 1 bit με πρόβλεψη δεν διαβάζονται
+@msg	the PSD file's layer data uses an unknown compression ({m})	τα δεδομένα επιπέδων του αρχείου PSD χρησιμοποιούν άγνωστη συμπίεση ({m})
+@msg	the PSD file's layer records are damaged	οι εγγραφές επιπέδων του αρχείου PSD είναι κατεστραμμένες
+@msg	the PSD file's layer groups are nested too deeply	οι ομάδες επιπέδων του αρχείου PSD είναι ένθετες σε υπερβολικό βάθος
+@msg	a layer of the PSD file is too large to read	ένα επίπεδο του αρχείου PSD είναι πολύ μεγάλο για ανάγνωση
+@msg	the PSD file's layers take more memory to read than allowed	τα επίπεδα του αρχείου PSD χρειάζονται περισσότερη μνήμη για ανάγνωση από όση επιτρέπεται
+@msg	the layers can't be read ({e}): the file opened as its merged image	τα επίπεδα δεν μπορούν να διαβαστούν ({e}): το αρχείο άνοιξε ως η συγχωνευμένη εικόνα του
@msg	{depth}-bit PSD files in this colour mode can't be read	τα αρχεία PSD {depth} bit δεν διαβάζονται σε αυτήν τη λειτουργία χρώματος
@msg	the PSD file is cut short	το αρχείο PSD είναι περικομμένο
@msg	the PSD file's header is damaged	η κεφαλίδα του αρχείου PSD είναι κατεστραμμένη
@@ -4959,7 +4959,13 @@ axis	Both	Ambos
@msg	the HEIC or HEIF file holds a kind of image that can't be read	el archivo HEIC o HEIF contiene un tipo de imagen que no se puede leer
@msg	HEIC and HEIF images can't be opened in this build	las imágenes HEIC y HEIF no se pueden abrir en esta compilación
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	la imagen PSD es demasiado grande para leerla ({_1} × {_2} píxeles)
-@msg	zipped 32-bit PSD image data with prediction can't be read	no se pueden leer datos de imagen PSD de 32 bits comprimidos en ZIP con predicción
+@msg	zipped 1-bit PSD image data with prediction can't be read	no se pueden leer datos de imagen PSD de 1 bit comprimidos en ZIP con predicción
+@msg	the PSD file's layer data uses an unknown compression ({m})	los datos de capa del archivo PSD usan una compresión desconocida ({m})
+@msg	the PSD file's layer records are damaged	los registros de capas del archivo PSD están dañados
+@msg	the PSD file's layer groups are nested too deeply	los grupos de capas del archivo PSD están anidados a demasiada profundidad
+@msg	a layer of the PSD file is too large to read	una capa del archivo PSD es demasiado grande para leerla
+@msg	the PSD file's layers take more memory to read than allowed	las capas del archivo PSD necesitan más memoria de la permitida para leerlas
+@msg	the layers can't be read ({e}): the file opened as its merged image	no se pueden leer las capas ({e}): el archivo se abrió como su imagen combinada
@msg	{depth}-bit PSD files in this colour mode can't be read	los archivos PSD de {depth} bits en este modo de color no se pueden leer
@msg	the PSD file is cut short	el archivo PSD está incompleto
@msg	the PSD file's header is damaged	el encabezado del archivo PSD está dañado
@@ -5143,7 +5143,13 @@ imageTrace	Outline	Ääriviiva
@msg	the HEIC or HEIF file holds a kind of image that can't be read	tässä HEIC- tai HEIF-tiedostossa on kuvatyyppi, jota ei voi lukea
@msg	HEIC and HEIF images can't be opened in this build	HEIC- ja HEIF-kuvia ei voi avata tässä versiossa
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	tämä PSD-kuva on liian suuri luettavaksi ({_1} × {_2} pikseliä)
-@msg	zipped 32-bit PSD image data with prediction can't be read	ennustusta käyttävää zip-pakattua 32-bittistä PSD-kuvadataa ei voi lukea
+@msg	zipped 1-bit PSD image data with prediction can't be read	ennustusta käyttävää zip-pakattua 1-bittistä PSD-kuvadataa ei voi lukea
+@msg	the PSD file's layer data uses an unknown compression ({m})	tämän PSD-tiedoston tasodata käyttää tuntematonta pakkausta ({m})
+@msg	the PSD file's layer records are damaged	tämän PSD-tiedoston tasotietueet ovat vahingoittuneet
+@msg	the PSD file's layer groups are nested too deeply	tämän PSD-tiedoston tasoryhmät ovat sisäkkäin liian syvällä
+@msg	a layer of the PSD file is too large to read	tämän PSD-tiedoston taso on liian suuri luettavaksi
+@msg	the PSD file's layers take more memory to read than allowed	tämän PSD-tiedoston tasojen lukeminen vaatii enemmän muistia kuin sallitaan
+@msg	the layers can't be read ({e}): the file opened as its merged image	tasoja ei voi lukea ({e}): tiedosto avattiin yhdistettynä kuvanaan
@msg	{depth}-bit PSD files in this colour mode can't be read	tässä väritilassa olevia {depth}-bittisiä PSD-tiedostoja ei voi lukea
@msg	the PSD file is cut short	tämä PSD-tiedosto on katkennut
@msg	the PSD file's header is damaged	tämän PSD-tiedoston otsake on vaurioitunut
@@ -4966,7 +4966,13 @@ axis	Both	Les deux
@msg	the HEIC or HEIF file holds a kind of image that can't be read	le fichier HEIC ou HEIF contient un type d'image qui ne peut pas être lu
@msg	HEIC and HEIF images can't be opened in this build	les images HEIC et HEIF ne peuvent pas être ouvertes dans cette version
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	l'image PSD est trop grande pour être lue ({_1} × {_2} pixels)
-@msg	zipped 32-bit PSD image data with prediction can't be read	les données d'image PSD 32 bits compressées en ZIP avec prédiction ne peuvent pas être lues
+@msg	zipped 1-bit PSD image data with prediction can't be read	les données d'image PSD 1 bit compressées en ZIP avec prédiction ne peuvent pas être lues
+@msg	the PSD file's layer data uses an unknown compression ({m})	les données de calque du fichier PSD utilisent une compression inconnue ({m})
+@msg	the PSD file's layer records are damaged	les enregistrements de calques du fichier PSD sont endommagés
+@msg	the PSD file's layer groups are nested too deeply	les groupes de calques du fichier PSD sont imbriqués trop profondément
+@msg	a layer of the PSD file is too large to read	un calque du fichier PSD est trop grand pour être lu
+@msg	the PSD file's layers take more memory to read than allowed	les calques du fichier PSD demandent plus de mémoire que permis pour être lus
+@msg	the layers can't be read ({e}): the file opened as its merged image	les calques ne peuvent pas être lus ({e}) : le fichier a été ouvert comme son image fusionnée
@msg	{depth}-bit PSD files in this colour mode can't be read	les fichiers PSD {depth} bits dans ce mode colorimétrique ne peuvent pas être lus
@msg	the PSD file is cut short	le fichier PSD est tronqué
@msg	the PSD file's header is damaged	l'en-tête du fichier PSD est endommagé
@@ -8000,7 +8000,13 @@ antiAlias	Sharp	शार्प
@msg	x and y must both be numbers	x और y दोनों संख्या होना चाहिए
@msg	You must choose a side pattern.	आपको एक साइड पैटर्न चुनना होगा।
@msg	Your unsaved changes are kept in this browser: reload the page to get them back.	इस ब्राउज़र में आपके बिना सेव किए गए बदलाव को रखा गया है: उन्हें वापस पाने के लिए पेज को फिर से लोड करें।
-@msg	zipped 32-bit PSD image data with prediction can't be read	भविष्यवाणी के साथ 32-bit PSD इमेज डेटा zipped नहीं किया जा सकता
+@msg	zipped 1-bit PSD image data with prediction can't be read	भविष्यवाणी के साथ zipped 1-bit PSD इमेज डेटा पढ़ा नहीं जा सकता
+@msg	the PSD file's layer data uses an unknown compression ({m})	PSD फ़ाइल का लेयर डेटा एक अज्ञात संपीड़न ({m}) का उपयोग करता है
+@msg	the PSD file's layer records are damaged	PSD फ़ाइल के लेयर रिकॉर्ड क्षतिग्रस्त हैं
+@msg	the PSD file's layer groups are nested too deeply	PSD फ़ाइल के लेयर समूह बहुत गहराई तक नेस्ट किए गए हैं
+@msg	a layer of the PSD file is too large to read	PSD फ़ाइल की एक लेयर पढ़ने के लिए बहुत बड़ी है
+@msg	the PSD file's layers take more memory to read than allowed	PSD फ़ाइल की लेयर पढ़ने के लिए अनुमति से अधिक मेमोरी चाहिए
+@msg	the layers can't be read ({e}): the file opened as its merged image	लेयर पढ़ी नहीं जा सकतीं ({e}): फ़ाइल अपनी मर्ज की गई इमेज के रूप में खुली
@msg	zone must be a string	zone: क्षेत्र एक स्ट्रिंग होना चाहिए
@msg	zone must be tab, center, left, right, top or bottom	zone को tab, center, left, right, top या bottom होना चाहिए
@msg	zone needs an anchor: dock beside a panel with anchor, or in a new dock column with side (Start or End)	zone: जोन को एक एंकर की आवश्यकता होती है: एंकर के साथ एक पैनल के बगल में, या साइड (स्टार्ट या एंड) के साथ एक नए डॉक कॉलम में
@@ -5566,7 +5566,13 @@ imageTrace	Outline	Körvonal
@msg	x and y must be provided together	az x és az y csak együtt adható meg
@msg	x and y must both be numbers	az x és az y is szám kell legyen
@msg	Your unsaved changes are kept in this browser: reload the page to get them back.	A nem mentett módosításaidat ez a böngésző megőrizte: töltsd újra az oldalt a visszakapásukhoz.
-@msg	zipped 32-bit PSD image data with prediction can't be read	a predikcióval tömörített 32 bites PSD-képadatok nem olvashatók
+@msg	zipped 1-bit PSD image data with prediction can't be read	a predikcióval tömörített 1 bites PSD-képadatok nem olvashatók
+@msg	the PSD file's layer data uses an unknown compression ({m})	a PSD-fájl rétegadatai ismeretlen tömörítést használnak ({m})
+@msg	the PSD file's layer records are damaged	a PSD-fájl rétegrekordjai sérültek
+@msg	the PSD file's layer groups are nested too deeply	a PSD-fájl rétegcsoportjai túl mélyen vannak egymásba ágyazva
+@msg	a layer of the PSD file is too large to read	a PSD-fájl egyik rétege túl nagy a beolvasáshoz
+@msg	the PSD file's layers take more memory to read than allowed	a PSD-fájl rétegeinek beolvasása több memóriát igényel a megengedettnél
+@msg	the layers can't be read ({e}): the file opened as its merged image	a rétegek nem olvashatók ({e}): a fájl az egyesített képeként nyílt meg
@msg	zone must be a string	a zone értéke szöveg lehet
@msg	zone must be tab, center, left, right, top or bottom	a zone értéke tab, center, left, right, top vagy bottom lehet
@msg	{_1} failed: {e}	sikertelen: {_1}: {e}
@@ -4822,7 +4822,13 @@ imageTrace	Outline	Kontur
@msg	the PSD file has an unknown colour mode ({m})	berkas PSD memiliki mode warna yang tidak dikenal ({m})
@msg	the PSD file's image data uses an unknown compression ({m})	data gambar berkas PSD menggunakan kompresi yang tidak dikenal ({m})
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	gambar PSD terlalu besar untuk dibaca ({_1} × {_2} piksel)
-@msg	zipped 32-bit PSD image data with prediction can't be read	data gambar PSD 32-bit terkompresi zip dengan prediksi tidak dapat dibaca
+@msg	zipped 1-bit PSD image data with prediction can't be read	data gambar PSD 1-bit terkompresi zip dengan prediksi tidak dapat dibaca
+@msg	the PSD file's layer data uses an unknown compression ({m})	data lapisan berkas PSD menggunakan kompresi yang tidak dikenal ({m})
+@msg	the PSD file's layer records are damaged	catatan lapisan berkas PSD rusak
+@msg	the PSD file's layer groups are nested too deeply	grup lapisan berkas PSD bersarang terlalu dalam
+@msg	a layer of the PSD file is too large to read	sebuah lapisan berkas PSD terlalu besar untuk dibaca
+@msg	the PSD file's layers take more memory to read than allowed	lapisan berkas PSD memerlukan lebih banyak memori untuk dibaca daripada yang diizinkan
+@msg	the layers can't be read ({e}): the file opened as its merged image	lapisan tidak dapat dibaca ({e}): berkas dibuka sebagai gambar gabungannya
@msg	{depth}-bit PSD files in this colour mode can't be read	berkas PSD {depth}-bit dalam mode warna ini tidak dapat dibaca
@msg	the PSD file is cut short	berkas PSD terpotong
@msg	the PSD file's header is damaged	header berkas PSD rusak
@@ -5002,7 +5002,13 @@ axis	Both	Entrambi
@msg	the HEIC or HEIF file holds a kind of image that can't be read	il file HEIC o HEIF contiene un tipo di immagine che non può essere letto
@msg	HEIC and HEIF images can't be opened in this build	le immagini HEIC e HEIF non possono essere aperte in questa build
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	l'immagine PSD è troppo grande per essere letta ({_1} × {_2} pixel)
-@msg	zipped 32-bit PSD image data with prediction can't be read	i dati immagine PSD a 32 bit compressi ZIP con previsione non possono essere letti
+@msg	zipped 1-bit PSD image data with prediction can't be read	i dati immagine PSD a 1 bit compressi ZIP con previsione non possono essere letti
+@msg	the PSD file's layer data uses an unknown compression ({m})	i dati dei livelli del file PSD usano una compressione sconosciuta ({m})
+@msg	the PSD file's layer records are damaged	i record dei livelli del file PSD sono danneggiati
+@msg	the PSD file's layer groups are nested too deeply	i gruppi di livelli del file PSD sono annidati troppo in profondità
+@msg	a layer of the PSD file is too large to read	un livello del file PSD è troppo grande per essere letto
+@msg	the PSD file's layers take more memory to read than allowed	i livelli del file PSD richiedono più memoria del consentito per essere letti
+@msg	the layers can't be read ({e}): the file opened as its merged image	i livelli non possono essere letti ({e}): il file è stato aperto come immagine unita
@msg	{depth}-bit PSD files in this colour mode can't be read	i file PSD a {depth} bit in questo metodo colore non possono essere letti
@msg	the PSD file is cut short	il file PSD è troncato
@msg	the PSD file's header is damaged	l'intestazione del file PSD è danneggiata
@@ -5043,7 +5043,13 @@ swatch	Bright Violet	ビビッドバイオレット
@msg	the HEIC or HEIF file holds a kind of image that can't be read	HEIC または HEIF ファイルには読み込めない種類の画像が含まれています
@msg	HEIC and HEIF images can't be opened in this build	このビルドでは HEIC と HEIF の画像を開けません
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	PSD 画像が大きすぎて読み込めません（{_1} × {_2} ピクセル）
-@msg	zipped 32-bit PSD image data with prediction can't be read	予測付き ZIP 圧縮の 32 bit PSD 画像データは読み込めません
+@msg	zipped 1-bit PSD image data with prediction can't be read	予測付き ZIP 圧縮の 1 bit PSD 画像データは読み込めません
+@msg	the PSD file's layer data uses an unknown compression ({m})	PSD ファイルのレイヤーデータの圧縮方式が不明です（{m}）
+@msg	the PSD file's layer records are damaged	PSD ファイルのレイヤーレコードが破損しています
+@msg	the PSD file's layer groups are nested too deeply	PSD ファイルのレイヤーグループの入れ子が深すぎます
+@msg	a layer of the PSD file is too large to read	PSD ファイルのレイヤーが大きすぎて読み込めません
+@msg	the PSD file's layers take more memory to read than allowed	PSD ファイルのレイヤーの読み込みに許容量を超えるメモリーが必要です
+@msg	the layers can't be read ({e}): the file opened as its merged image	レイヤーを読み込めません（{e}）：ファイルは統合画像として開かれました
@msg	{depth}-bit PSD files in this colour mode can't be read	このカラーモードの {depth} bit PSD ファイルは読み込めません
@msg	the PSD file is cut short	PSD ファイルが途中で切れています
@msg	the PSD file's header is damaged	PSD ファイルのヘッダーが破損しています
@@ -4658,7 +4658,13 @@ font-technology	Variable	ცვლადი
@msg	the HEIC or HEIF file holds a kind of image that can't be read	HEIC ან HEIF ფაილი შეიცავს გამოსახულების ტიპს, რომლის წაკითხვაც შეუძლებელია
@msg	HEIC and HEIF images can't be opened in this build	ამ ვერსიაში HEIC და HEIF გამოსახულებების გახსნა შეუძლებელია
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	PSD გამოსახულება ზედმეტად დიდია წასაკითხად ({_1} × {_2} პიქსელი)
-@msg	zipped 32-bit PSD image data with prediction can't be read	zip-ით შეკუმშული 32-ბიტიანი PSD გამოსახულების მონაცემების წაკითხვა პროგნოზირებით ვერ ხერხდება
+@msg	zipped 1-bit PSD image data with prediction can't be read	zip-ით შეკუმშული 1-ბიტიანი PSD გამოსახულების მონაცემების წაკითხვა პროგნოზირებით ვერ ხერხდება
+@msg	the PSD file's layer data uses an unknown compression ({m})	PSD ფაილის შრეების მონაცემები უცნობ შეკუმშვას იყენებს ({m})
+@msg	the PSD file's layer records are damaged	PSD ფაილის შრეების ჩანაწერები დაზიანებულია
+@msg	the PSD file's layer groups are nested too deeply	PSD ფაილის შრეების ჯგუფები ზედმეტად ღრმადაა ჩადგმული
+@msg	a layer of the PSD file is too large to read	PSD ფაილის შრე ზედმეტად დიდია წასაკითხად
+@msg	the PSD file's layers take more memory to read than allowed	PSD ფაილის შრეების წასაკითხად დაშვებულზე მეტი მეხსიერებაა საჭირო
+@msg	the layers can't be read ({e}): the file opened as its merged image	შრეების წაკითხვა ვერ ხერხდება ({e}): ფაილი გაიხსნა როგორც მისი გაერთიანებული გამოსახულება
@msg	{depth}-bit PSD files in this colour mode can't be read	ამ ფერის რეჟიმში {depth}-ბიტიანი PSD ფაილების წაკითხვა ვერ ხერხდება
@msg	the PSD file is cut short	PSD ფაილი შეკვეცილია
@msg	the PSD file's header is damaged	PSD ფაილის სათაური დაზიანებულია
@@ -4970,7 +4970,13 @@ theme	Appearance	외관
@msg	the HEIC or HEIF file holds a kind of image that can't be read	HEIC 또는 HEIF 파일에 읽을 수 없는 종류의 이미지가 있습니다
@msg	HEIC and HEIF images can't be opened in this build	이 빌드에서는 HEIC 및 HEIF 이미지를 열 수 없습니다
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	PSD 이미지가 너무 커서 읽을 수 없습니다({_1} × {_2}픽셀)
-@msg	zipped 32-bit PSD image data with prediction can't be read	예측이 적용된 ZIP 압축 32비트 PSD 이미지 데이터는 읽을 수 없습니다
+@msg	zipped 1-bit PSD image data with prediction can't be read	예측이 적용된 ZIP 압축 1비트 PSD 이미지 데이터는 읽을 수 없습니다
+@msg	the PSD file's layer data uses an unknown compression ({m})	PSD 파일의 레이어 데이터가 알 수 없는 압축({m})을 사용합니다
+@msg	the PSD file's layer records are damaged	PSD 파일의 레이어 레코드가 손상되었습니다
+@msg	the PSD file's layer groups are nested too deeply	PSD 파일의 레이어 그룹이 너무 깊이 중첩되어 있습니다
+@msg	a layer of the PSD file is too large to read	PSD 파일의 레이어가 너무 커서 읽을 수 없습니다
+@msg	the PSD file's layers take more memory to read than allowed	PSD 파일의 레이어를 읽는 데 허용된 것보다 많은 메모리가 필요합니다
+@msg	the layers can't be read ({e}): the file opened as its merged image	레이어를 읽을 수 없습니다({e}): 파일이 병합된 이미지로 열렸습니다
@msg	{depth}-bit PSD files in this colour mode can't be read	이 색상 모드의 {depth}비트 PSD 파일은 읽을 수 없습니다
@msg	the PSD file is cut short	PSD 파일이 잘려 있습니다
@msg	the PSD file's header is damaged	PSD 파일의 헤더가 손상되었습니다
@@ -4834,7 +4834,13 @@ imageTrace	Outline	Contour
@msg	the PSD file has an unknown colour mode ({m})	het PSD-bestand heeft een onbekende kleurmodus ({m})
@msg	the PSD file's image data uses an unknown compression ({m})	de afbeeldingsgegevens van het PSD-bestand gebruiken een onbekende compressie ({m})
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	de PSD-afbeelding is te groot om te lezen ({_1} × {_2} pixels)
-@msg	zipped 32-bit PSD image data with prediction can't be read	gezipte 32-bits PSD-afbeeldingsgegevens met voorspelling kunnen niet worden gelezen
+@msg	zipped 1-bit PSD image data with prediction can't be read	gezipte 1-bits PSD-afbeeldingsgegevens met voorspelling kunnen niet worden gelezen
+@msg	the PSD file's layer data uses an unknown compression ({m})	de laaggegevens van het PSD-bestand gebruiken een onbekende compressie ({m})
+@msg	the PSD file's layer records are damaged	de laagrecords van het PSD-bestand zijn beschadigd
+@msg	the PSD file's layer groups are nested too deeply	de laaggroepen van het PSD-bestand zijn te diep genest
+@msg	a layer of the PSD file is too large to read	een laag van het PSD-bestand is te groot om te lezen
+@msg	the PSD file's layers take more memory to read than allowed	de lagen van het PSD-bestand hebben meer geheugen nodig om te lezen dan toegestaan
+@msg	the layers can't be read ({e}): the file opened as its merged image	de lagen kunnen niet worden gelezen ({e}): het bestand is geopend als zijn samengevoegde afbeelding
@msg	{depth}-bit PSD files in this colour mode can't be read	{depth}-bits PSD-bestanden in deze kleurmodus kunnen niet worden gelezen
@msg	the PSD file is cut short	het PSD-bestand is afgekapt
@msg	the PSD file's header is damaged	de header van het PSD-bestand is beschadigd
@@ -5067,7 +5067,13 @@ imageTrace	Outline	Kontur
@msg	the HEIC or HEIF file holds a kind of image that can't be read	plik HEIC lub HEIF zawiera rodzaj obrazu, którego nie można odczytać
@msg	HEIC and HEIF images can't be opened in this build	obrazów HEIC i HEIF nie można otworzyć w tej wersji
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	obraz PSD jest zbyt duży, aby go odczytać ({_1} × {_2} pikseli)
-@msg	zipped 32-bit PSD image data with prediction can't be read	nie można odczytać spakowanych 32-bitowych danych obrazu PSD z predykcją
+@msg	zipped 1-bit PSD image data with prediction can't be read	nie można odczytać spakowanych 1-bitowych danych obrazu PSD z predykcją
+@msg	the PSD file's layer data uses an unknown compression ({m})	dane warstw pliku PSD używają nieznanej kompresji ({m})
+@msg	the PSD file's layer records are damaged	rekordy warstw pliku PSD są uszkodzone
+@msg	the PSD file's layer groups are nested too deeply	grupy warstw pliku PSD są zagnieżdżone zbyt głęboko
+@msg	a layer of the PSD file is too large to read	warstwa pliku PSD jest zbyt duża, aby ją odczytać
+@msg	the PSD file's layers take more memory to read than allowed	odczytanie warstw pliku PSD wymaga więcej pamięci, niż jest dozwolone
+@msg	the layers can't be read ({e}): the file opened as its merged image	nie można odczytać warstw ({e}): plik otwarto jako jego scalony obraz
@msg	{depth}-bit PSD files in this colour mode can't be read	nie można odczytać {depth}-bitowych plików PSD w tym trybie koloru
@msg	the PSD file is cut short	plik PSD jest ucięty
@msg	the PSD file's header is damaged	nagłówek pliku PSD jest uszkodzony
@@ -4467,7 +4467,13 @@ axis	Both	Ambos
@msg	the HEIC or HEIF file holds a kind of image that can't be read	o arquivo HEIC ou HEIF contém um tipo de imagem que não pode ser lido
@msg	HEIC and HEIF images can't be opened in this build	imagens HEIC e HEIF não podem ser abertas nesta versão
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	a imagem PSD é grande demais para ser lida ({_1} × {_2} pixels)
-@msg	zipped 32-bit PSD image data with prediction can't be read	dados de imagem PSD de 32 bits compactados em zip com previsão não podem ser lidos
+@msg	zipped 1-bit PSD image data with prediction can't be read	dados de imagem PSD de 1 bit compactados em zip com previsão não podem ser lidos
+@msg	the PSD file's layer data uses an unknown compression ({m})	os dados de camada do arquivo PSD usam uma compactação desconhecida ({m})
+@msg	the PSD file's layer records are damaged	os registros de camadas do arquivo PSD estão danificados
+@msg	the PSD file's layer groups are nested too deeply	os grupos de camadas do arquivo PSD estão aninhados profundamente demais
+@msg	a layer of the PSD file is too large to read	uma camada do arquivo PSD é grande demais para ser lida
+@msg	the PSD file's layers take more memory to read than allowed	as camadas do arquivo PSD precisam de mais memória do que o permitido para serem lidas
+@msg	the layers can't be read ({e}): the file opened as its merged image	as camadas não podem ser lidas ({e}): o arquivo foi aberto como sua imagem mesclada
@msg	{depth}-bit PSD files in this colour mode can't be read	arquivos PSD de {depth} bits neste modo de cor não podem ser lidos
@msg	the PSD file is cut short	o arquivo PSD está incompleto
@msg	the PSD file's header is damaged	o cabeçalho do arquivo PSD está danificado
@@ -4998,7 +4998,13 @@ axis	Both	Оба
@msg	the HEIC or HEIF file holds a kind of image that can't be read	файл HEIC или HEIF содержит изображение такого типа, которое не удается прочитать
@msg	HEIC and HEIF images can't be opened in this build	изображения HEIC и HEIF нельзя открыть в этой сборке
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	изображение PSD слишком велико для чтения ({_1} × {_2} пикс.)
-@msg	zipped 32-bit PSD image data with prediction can't be read	32-битные данные изображения PSD со сжатием ZIP с предсказанием не читаются
+@msg	zipped 1-bit PSD image data with prediction can't be read	1-битные данные изображения PSD со сжатием ZIP с предсказанием не читаются
+@msg	the PSD file's layer data uses an unknown compression ({m})	данные слоёв файла PSD используют неизвестное сжатие ({m})
+@msg	the PSD file's layer records are damaged	записи слоёв файла PSD повреждены
+@msg	the PSD file's layer groups are nested too deeply	группы слоёв файла PSD вложены слишком глубоко
+@msg	a layer of the PSD file is too large to read	слой файла PSD слишком велик для чтения
+@msg	the PSD file's layers take more memory to read than allowed	для чтения слоёв файла PSD нужно больше памяти, чем разрешено
+@msg	the layers can't be read ({e}): the file opened as its merged image	не удаётся прочитать слои ({e}): файл открыт как сведённое изображение
@msg	{depth}-bit PSD files in this colour mode can't be read	{depth}-битные файлы PSD в этом цветовом режиме не читаются
@msg	the PSD file is cut short	файл PSD обрезан
@msg	the PSD file's header is damaged	заголовок файла PSD повреждён
@@ -4875,7 +4875,13 @@ axis	Both	Båda
@msg	the HEIC or HEIF file holds a kind of image that can't be read	HEIC- eller HEIF-filen innehåller en typ av bild som inte kan läsas
@msg	HEIC and HEIF images can't be opened in this build	HEIC- och HEIF-bilder kan inte öppnas i den här versionen
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	PSD-bilden är för stor för att läsas ({_1} × {_2} pixlar)
-@msg	zipped 32-bit PSD image data with prediction can't be read	zippad 32-bitars PSD-bilddata med prediktion kan inte läsas
+@msg	zipped 1-bit PSD image data with prediction can't be read	zippad 1-bitars PSD-bilddata med prediktion kan inte läsas
+@msg	the PSD file's layer data uses an unknown compression ({m})	PSD-filens lagerdata använder en okänd komprimering ({m})
+@msg	the PSD file's layer records are damaged	PSD-filens lagerposter är skadade
+@msg	the PSD file's layer groups are nested too deeply	PSD-filens lagergrupper är kapslade för djupt
+@msg	a layer of the PSD file is too large to read	ett lager i PSD-filen är för stort för att läsas
+@msg	the PSD file's layers take more memory to read than allowed	PSD-filens lager kräver mer minne för att läsas än vad som tillåts
+@msg	the layers can't be read ({e}): the file opened as its merged image	lagren kan inte läsas ({e}): filen öppnades som sin sammanslagna bild
@msg	{depth}-bit PSD files in this colour mode can't be read	{depth}-bitars PSD-filer i det här färgläget kan inte läsas
@msg	the PSD file is cut short	PSD-filen är avkortad
@msg	the PSD file's header is damaged	PSD-filens huvud är skadat
@@ -4704,7 +4704,13 @@ axis	Both	Her İkisi
@msg	the HEIC or HEIF file holds a kind of image that can't be read	HEIC veya HEIF dosyası okunamayan türde bir görüntü içeriyor
@msg	HEIC and HEIF images can't be opened in this build	HEIC ve HEIF görüntüleri bu derlemede açılamıyor
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	PSD görüntüsü okunamayacak kadar büyük ({_1} × {_2} piksel)
-@msg	zipped 32-bit PSD image data with prediction can't be read	Tahmin içeren sıkıştırılmış 32 bit PSD görüntü verileri okunamıyor
+@msg	zipped 1-bit PSD image data with prediction can't be read	Tahmin içeren sıkıştırılmış 1 bit PSD görüntü verileri okunamıyor
+@msg	the PSD file's layer data uses an unknown compression ({m})	PSD dosyasının katman verileri bilinmeyen bir sıkıştırma kullanıyor ({m})
+@msg	the PSD file's layer records are damaged	PSD dosyasının katman kayıtları hasarlı
+@msg	the PSD file's layer groups are nested too deeply	PSD dosyasının katman grupları çok derin iç içe geçmiş
+@msg	a layer of the PSD file is too large to read	PSD dosyasının bir katmanı okunamayacak kadar büyük
+@msg	the PSD file's layers take more memory to read than allowed	PSD dosyasının katmanlarını okumak izin verilenden fazla bellek gerektiriyor
+@msg	the layers can't be read ({e}): the file opened as its merged image	katmanlar okunamıyor ({e}): dosya birleştirilmiş görüntüsü olarak açıldı
@msg	{depth}-bit PSD files in this colour mode can't be read	Bu renk modunda {depth}-bit PSD dosyaları okunamaz
@msg	the PSD file is cut short	PSD dosyası kısa kesildi
@msg	the PSD file's header is damaged	PSD dosyasının başlığı hasarlı
@@ -4986,7 +4986,13 @@ axis	Both	Обидві
@msg	the HEIC or HEIF file holds a kind of image that can't be read	файл HEIC або HEIF містить зображення такого типу, яке не вдається прочитати
@msg	HEIC and HEIF images can't be opened in this build	зображення HEIC і HEIF не можна відкрити в цій збірці
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	зображення PSD завелике для читання ({_1} × {_2} пікс.)
-@msg	zipped 32-bit PSD image data with prediction can't be read	32-бітні дані зображення PSD зі стисненням ZIP із передбаченням не читаються
+@msg	zipped 1-bit PSD image data with prediction can't be read	1-бітні дані зображення PSD зі стисненням ZIP із передбаченням не читаються
+@msg	the PSD file's layer data uses an unknown compression ({m})	дані шарів файлу PSD використовують невідоме стиснення ({m})
+@msg	the PSD file's layer records are damaged	записи шарів файлу PSD пошкоджено
+@msg	the PSD file's layer groups are nested too deeply	групи шарів файлу PSD вкладено надто глибоко
+@msg	a layer of the PSD file is too large to read	шар файлу PSD завеликий для читання
+@msg	the PSD file's layers take more memory to read than allowed	для читання шарів файлу PSD потрібно більше пам’яті, ніж дозволено
+@msg	the layers can't be read ({e}): the file opened as its merged image	не вдається прочитати шари ({e}): файл відкрито як зведене зображення
@msg	{depth}-bit PSD files in this colour mode can't be read	{depth}-бітні файли PSD у цьому колірному режимі не читаються
@msg	the PSD file is cut short	файл PSD обрізаний
@msg	the PSD file's header is damaged	заголовок файлу PSD пошкоджено
@@ -5234,7 +5234,13 @@ theme	Appearance	Giao diện
@msg	x and y must be provided together	x và y phải được cung cấp cùng nhau
@msg	x and y must both be numbers	x và y đều phải là số
@msg	Your unsaved changes are kept in this browser: reload the page to get them back.	Các thay đổi chưa lưu được giữ trong trình duyệt này: tải lại trang để lấy lại.
-@msg	zipped 32-bit PSD image data with prediction can't be read	dữ liệu ảnh PSD 32-bit nén với dự đoán không thể đọc được
+@msg	zipped 1-bit PSD image data with prediction can't be read	dữ liệu ảnh PSD 1-bit nén với dự đoán không thể đọc được
+@msg	the PSD file's layer data uses an unknown compression ({m})	dữ liệu lớp của tệp PSD dùng nén không xác định ({m})
+@msg	the PSD file's layer records are damaged	bản ghi lớp của tệp PSD bị hỏng
+@msg	the PSD file's layer groups are nested too deeply	các nhóm lớp của tệp PSD lồng nhau quá sâu
+@msg	a layer of the PSD file is too large to read	một lớp của tệp PSD quá lớn để đọc
+@msg	the PSD file's layers take more memory to read than allowed	các lớp của tệp PSD cần nhiều bộ nhớ để đọc hơn mức cho phép
+@msg	the layers can't be read ({e}): the file opened as its merged image	không thể đọc các lớp ({e}): tệp được mở dưới dạng ảnh đã gộp
@msg	zone must be a string	zone phải là chuỗi
@msg	zone must be tab, center, left, right, top or bottom	zone phải là tab, center, left, right, top hoặc bottom
@msg	{_1} failed: {e}	{_1} thất bại: {e}
@@ -4747,7 +4747,13 @@ imageTrace	Outline	轮廓
@msg	the HEIC or HEIF file holds a kind of image that can't be read	HEIC 或 HEIF 文件包含无法读取的图像类型
@msg	HEIC and HEIF images can't be opened in this build	此版本无法打开 HEIC 和 HEIF 图像
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	PSD 图像过大，无法读取 ({_1} × {_2} 像素)
-@msg	zipped 32-bit PSD image data with prediction can't be read	无法读取带预测的 ZIP 压缩 32 位 PSD 图像数据
+@msg	zipped 1-bit PSD image data with prediction can't be read	无法读取带预测的 ZIP 压缩 1 位 PSD 图像数据
+@msg	the PSD file's layer data uses an unknown compression ({m})	PSD 文件的图层数据使用了未知的压缩方式 ({m})
+@msg	the PSD file's layer records are damaged	PSD 文件的图层记录已损坏
+@msg	the PSD file's layer groups are nested too deeply	PSD 文件的图层组嵌套过深
+@msg	a layer of the PSD file is too large to read	PSD 文件的某个图层过大，无法读取
+@msg	the PSD file's layers take more memory to read than allowed	读取 PSD 文件的图层所需内存超过允许值
+@msg	the layers can't be read ({e}): the file opened as its merged image	无法读取图层 ({e})：文件已作为合并图像打开
@msg	{depth}-bit PSD files in this colour mode can't be read	无法读取此颜色模式下的 {depth} 位 PSD 文件
@msg	the PSD file is cut short	PSD 文件不完整
@msg	the PSD file's header is damaged	PSD 文件头已损坏
@@ -2556,7 +2556,13 @@ file-filter	Templates	範本
@msg	the HEIC or HEIF file holds a kind of image that can't be read	HEIC 或 HEIF 檔案包含無法讀取的影像類型
@msg	HEIC and HEIF images can't be opened in this build	此版本無法開啟 HEIC 和 HEIF 影像
@msg	the PSD image is too large to read ({_1} × {_2} pixels)	PSD 影像過大，無法讀取 ({_1} × {_2} 像素)
-@msg	zipped 32-bit PSD image data with prediction can't be read	無法讀取使用預測的 ZIP 壓縮 32 位元 PSD 影像資料
+@msg	zipped 1-bit PSD image data with prediction can't be read	無法讀取使用預測的 ZIP 壓縮 1 位元 PSD 影像資料
+@msg	the PSD file's layer data uses an unknown compression ({m})	PSD 檔案的圖層資料使用了不明的壓縮方式 ({m})
+@msg	the PSD file's layer records are damaged	PSD 檔案的圖層記錄已損毀
+@msg	the PSD file's layer groups are nested too deeply	PSD 檔案的圖層群組巢狀過深
+@msg	a layer of the PSD file is too large to read	PSD 檔案的某個圖層過大，無法讀取
+@msg	the PSD file's layers take more memory to read than allowed	讀取 PSD 檔案的圖層所需記憶體超過允許值
+@msg	the layers can't be read ({e}): the file opened as its merged image	無法讀取圖層 ({e})：檔案已以合併影像開啟
@msg	{depth}-bit PSD files in this colour mode can't be read	無法讀取此色彩模式的 {depth} 位元 PSD 檔案
@msg	the PSD file is cut short	PSD 檔案不完整
@msg	the PSD file's header is damaged	PSD 檔頭已損毀
@@ -293,8 +293,8 @@ Names in the editing data that aren't UTF-8 (layers, objects, artboards, colors,
 | DXF | open, export | yes | yes (R12–2018) | R13–2018 closed SPLINE flags and control-point closure on import verified (#1299); circular cubic paths export as native CIRCLE/ARC where stroke semantics permit; R12 weighted strokes remain POLYLINE while non-circular curves keep the existing fallback (`crates/cad/src/tests.rs`); [Autodesk group 70](https://help.autodesk.com/cloudhelp/2024/ENU/AutoCAD-DXF/files/GUID-E1F884F8-AA90-4864-A215-3182D47A9C74.htm). DXF 2000–2018 LAYOUT objects write the paper image origin as 148/149 (was a stray 158), the shade plot codes (2004+) and the model type flag, and the plot style placeholder carries no subclass marker (#3085; structure test `r2000_and_later_files_have_the_structure_cad_apps_require`, checked with ezdxf's audit; not yet confirmed in Autodesk Fusion). CNC preset and VCarve QA remain open |
 | DWG | open, export | no | no | no open spec; DXF instead |
 | EMF / WMF | open, export | yes | yes | an oversized embedded PNG or JPEG is refused from its header, before any pixels are decoded (#1776) |
-| PSD | open, place, export | yes (merged image, every mode and depth; `.psd` and `.pdd`) | yes (layered, max editability) | placing as layers (Photoshop Import Options) missing; the embedded ICC profile's tags are 4-byte aligned (#1584) |
-| PSB | open | yes (merged image) | no | |
+| PSD | open, place, export | yes (open: layers as layers, or the merged image with `layers: false`; place: merged image; every mode and depth; `.psd` and `.pdd`) | yes (layered, max editability) | placing as layers and a PSD import options dialog missing; the embedded ICC profile's tags are 4-byte aligned (#1584) |
+| PSB | open | yes (layers as layers, or the merged image) | no | |
 | PNG / JPEG / GIF / BMP / TIFF / Targa | open, place, export | yes (PNG: `.png` and `.pns`; BMP: `.bmp`, `.dib` and `.rle`; Targa: `.tga`, `.vda`, `.icb` and `.vst`, raw or run-length encoded, with a 16-bit file's one-bit alpha) | yes; TIFF is also selectable in Export for Screens and Asset Export with its existing options | Targa: `tests_tiffbmp.rs`, `tests/links.rs`; TIFF: grayscale with an alpha channel or other extra channels reads (#1466 in part), and so do files that store each channel as its own plane (PlanarConfiguration 2), CMYK ones with their ink amounts, and 1-bit files compressed with CCITT Group 3 (Compression 2 and 3, one- and two-dimensional rows); the ICC profiles embedded in JPEG and TIFF have 4-byte aligned tags (#1584); PNG export marks its colours as sRGB (`embedIcc`, an `sRGB` chunk; no ICC profile is embedded, #2221) |
 | WebP | export (Export for Screens) | yes | yes (lossless only; lossy written lossless with a warning) | |
 | JPEG XL `.jxl` | — | yes (first frame; 16-bit and floating-point samples as 8 bits, alpha kept; CMYK refused) | no | decoded with jxl-oxide; the size is checked from the header before decoding; container Exif resolution sizes opened and placed images; tests in `crates/engine/src/cmd/fileio/tests_jxlread.rs` and `crates/engine/tests/import_fuzz.rs` |
@@ -490,7 +490,7 @@ opens the picker through `run_command` with the remote backend.
 | `invoke_menu` | `{command, params?}` | Invokes a menu item by command id. UI commands such as `view.*` and `window.*` are in `command_list` with `ui: true`; running them needs the desktop app (`--connect`). |
 | `open_panel` | `{panel}` | Remote only. `panel` is a panel id (`layers`, `swatches`, `colorGuide`, …, as `window.panel` takes) or its display label (`"Color Guide"`), in any case. |
 | `screenshot` | `{path?, scale?, artboard?, window?, max_side?, traceViews?}` | Returns MCP image content (`image/png`, base64) plus a text block. Renders the artboard with the pixels of a PNG `export` with `background: "white"` at the same scale; `traceViews:true` draws Image Trace objects in the view set with `imageTrace.setView`, as in the app's window; `window:true` captures the app window (remote only), as `ui_screenshot` does, and `max_side` (1–4096, window captures only) scales the returned image down as described for `ui_screenshot`. With `path` the backend (the headless session or the app) writes the PNG there too; a window capture written there keeps its full size with `max_side`. |
-| `open_file` | `{path, importer?, params?}` | Opens any readable file as a new active document: `.vectorcraft`/`.drawcraft`, `.vctemplate`, `.svg`/`.svgz`, `.pdf`/`.ai`, `.ait`, `.eps`/`.epsf`, `.ps`, `.dxf`, `.emf`, `.wmf`, PNG (`.png`/`.pns`), JPEG, GIF, WebP, TIFF, BMP (`.bmp`/`.dib`/`.rle`), Targa (`.tga`/`.vda`/`.icb`/`.vst`), PCX, Pixar (`.pxr`), JPEG 2000 (`.jpf`/`.jpx`/`.jp2`/`.j2k`/`.j2c`/`.jpc`), HEIC/HEIF (`.heic`/`.heif`), JPEG XL (`.jxl`), PSD (`.psd`/`.pdd`)/PSB (an image opens as a document of its pixel size; a Photoshop file as its merged image; a JPEG XL file as its first frame). Templates (`.vctemplate`, `.ait`) open as a new untitled document. PDF, `.ai` and SVG files saved with Preserve Editing reopen as the document they carry. The reply is `document.open`'s: its `warnings` say what didn't come in as it was (an EPS whose PostScript can't be read opens as its preview, and the warning names the PostScript error, the operator and the procedure). A file of an extension only an installed importer plug-in lists opens with that importer ([Plug-ins](#plug-ins)); `importer: "plugin.<id>"` opens the file with the importer it names, which must list the file's extension, also one a built-in format reads (in the app, as File › Open With does), and `params` gives that importer's parameters (their defaults when omitted). `run_command document.formats` lists the formats. |
+| `open_file` | `{path, importer?, params?}` | Opens any readable file as a new active document: `.vectorcraft`/`.drawcraft`, `.vctemplate`, `.svg`/`.svgz`, `.pdf`/`.ai`, `.ait`, `.eps`/`.epsf`, `.ps`, `.dxf`, `.emf`, `.wmf`, PNG (`.png`/`.pns`), JPEG, GIF, WebP, TIFF, BMP (`.bmp`/`.dib`/`.rle`), Targa (`.tga`/`.vda`/`.icb`/`.vst`), PCX, Pixar (`.pxr`), JPEG 2000 (`.jpf`/`.jpx`/`.jp2`/`.j2k`/`.j2c`/`.jpc`), HEIC/HEIF (`.heic`/`.heif`), JPEG XL (`.jxl`), PSD (`.psd`/`.pdd`)/PSB (an image opens as a document of its pixel size; a PSD or PSB file with its layers as layers, or as its merged image through `run_command document.open` with `layers: false`; a JPEG XL file as its first frame). Templates (`.vctemplate`, `.ait`) open as a new untitled document. PDF, `.ai` and SVG files saved with Preserve Editing reopen as the document they carry. The reply is `document.open`'s: its `warnings` say what didn't come in as it was (an EPS whose PostScript can't be read opens as its preview, and the warning names the PostScript error, the operator and the procedure). A file of an extension only an installed importer plug-in lists opens with that importer ([Plug-ins](#plug-ins)); `importer: "plugin.<id>"` opens the file with the importer it names, which must list the file's extension, also one a built-in format reads (in the app, as File › Open With does), and `params` gives that importer's parameters (their defaults when omitted). `run_command document.formats` lists the formats. |
 | `save_file` | `{path?, compress?, version?, preview?, precision?, options?}` | Runs `document.save`: the document's own file in its own format (native `.vectorcraft` unless it was opened from or saved as SVG, PDF or a restorable `.ai`; then `warnings` say what that format loses). A path's extension picks the format (`.vectorcraft`, `.vctemplate`, `.pdf`, `.svg`, `.svgz`, `.ai`: a PDF carrying the native document, which reopens editable). For a native file, `compress: true` gzips it (default: the `useCompression` preference, Preferences › File Handling › Use Compression), `version` (1 to 4) writes it for an older VectorCraft (1 and 2 are never compressed, and `version: 2` with `compress: true` is an error), `preview: true` embeds a PNG of the first artboard, and `precision` (0 to 9) rounds path anchors and handles to that many decimal places for that save only (colors, transforms and type stay exact). `options` passes the format's save options as `run_command document.formats` lists them. When `compress`, `version`, `preview` or `precision` is given both at the top level and in `options` with different values, the call is an error (`` `compress: true` and `options.compress: false` disagree: give the option once ``) and nothing is written. A key in `options` that no save format takes is an error, and nothing is written (see Parameter keys). The save drops each option the written format doesn't read. The reply's `warnings` then name each such option given (for example `` `compress` was not used: SVG files don't read it `` for an `.svg` path, and `` `options.preview` was not used: … `` for a key in `options`; a `.ai` file reads `compress` but not `version`, `preview` or `precision`). For a `.ai` file, these warnings name the kind of `.ai` written: a legacy .ai (version 7) for `aiVersion: "7"`, a non-PDF-compatible .ai for `pdfCompatible: false`, and a PDF-compatible .ai otherwise, including a save that reuses the options the document was last saved with. `run_command document.save` and the other save commands refuse any option given beside the path and in `options` with different values, and give the same warnings for a top-level `compress`, `version`, `preview` or `precision` and for each key in `options` that the format doesn't read. The headless session and the app receive the same `app.save` params, and the app is also sent `wait: true`: the call returns once the file is written, or with the error (such as a path outside the write root), even with Background Save on. When the save asks first (the question before replacing a file that opened with losses, or on macOS and Linux the file dialog for an untitled document without `path`), the reply is `{pending}` or `"cancelled"` as before, and the save that runs after the answer uses the Background Save preference. |
 | `export` | `{path?, format?, scale?, artboard?, range?, selection?, outlineText?, options?}` | `svg`, `svgz`, `pdf`, `ai` (the PDF-compatible `.ai` that Save writes, which carries the document when every artboard is written in order), `eps`, `dxf`, `emf`, `wmf`, `png`, `jpg`, `webp`, `gif`, `png8` (an indexed `.png`), `tiff`, `bmp`, `tga`, `psd` (layered), `txt` (the document's text), `vectorcraft` or `template` (a native template). The tool's `format` enum and `document.formats` list them, generated from the engine's format table. When `format` is omitted, it comes from the path's extension. PDF and `.ai` write one page per artboard: all of them, or `artboard` (0-based) / `range` (`"1-3, 5"`, 1-based). SVG and SVGZ write one file per chosen artboard. EPS writes one file of the visible art; with `artboard`, `range`, `options.artboards` or `options: {"useArtboards": true}` it writes one file per chosen artboard, after a central file of the visible art when there are two or more, and `useArtboards: false` keeps the one file. Rasters, DXF, EMF and WMF write one artboard, or one file per chosen artboard with `options: {"useArtboards": true}`. Rasters also take `options: {"rect": [x, y, width, height]}` (page points, y down): that area of the page at the given `ppi`/`scale`, without an artboard and without changing the document; it is refused with `artboard`, `artboards`, `range` or `useArtboards`, with a non-positive or non-finite size, and for non-raster formats. `options` carries more format options (e.g. `{"quality": 80}` for JPEG). `selection: true` exports the selected objects cropped to their bounds (the reply adds their `bounds`, and reports `format` and the encoder's `warnings` as a whole-document export does); `outlineText: true` writes SVG text as paths. Template layers are left out, live effects are kept, and exporting `vectorcraft` never changes the document's path. Without `path` the bytes come back as `dataBase64`. Both backends run the same `document.export` call. |
 | `add_text` | `{text, x?, y?, width?, height?, fit?, fitMinPercent?, path?, mode?, pathEffect?, size?, font?, color?, justify?, vertical?}` | Point type at (x, y) (`justify`: `left`, `center` or `right` starts, centres or ends each line on x); area type with `width`/`height` (`fit`: `none`, `autoHeight`, `shrinkText`, as `text.areaOptions`); or `path` + `mode` (`area`/`onPath`) to flow text in or along a path, with `pathEffect` (`rainbow`, `skew`, `3dRibbon`, `stairStep`, `gravity`; SVG export writes type on a path with any effect other than `rainbow` as outlines, with a warning); `justify` (also `auto`, `justifyAll`) aligns the paragraphs of every kind, as `text.setStyle` does later. `vertical: true` uses the existing vertical writing mode for every kind (default `false`, horizontal). Returns `{id}`, with `overflow: true` when the text doesn't fit its frame or path. |
@@ -6198,12 +6198,67 @@ appearance of their own or knockout stay one pixel layer. Hidden layers and obje
 `hiddenLayers: true` writes them as hidden layers. `layers: false` writes one flat image, on white where nothing is
 drawn. Files are at most 30000 pixels a side.

-Photoshop documents (`.psd`, and `.psb`, the large document format) open and place as their merged image, the
-flattened picture every Photoshop file carries (layers aren't read): Bitmap, Grayscale, Duotone, Indexed, RGB, CMYK
+PSD files (`.psd`, and `.psb`, the large document format) place as their merged image, the
+flattened picture every PSD file carries: Bitmap, Grayscale, Duotone, Indexed, RGB, CMYK
 (converted with the colour settings' CMYK) and Lab, at 1, 8, 16 and 32 bits per channel, sized by their resolution.
 A document with transparency keeps it. `file.place {path}` links the file like any image (`links.update` reads it
 again when it changes); Multichannel files are refused.

+`document.open` converts a PSD or PSB file's layers to objects. In
+[PSD import options](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-from-other-apps/photoshop-import-options.html),
+the option that converts layers to objects keeps as much of the layer structure as it can, merges the layers of a
+clipping mask into one layer and discards hidden layers that require merging; the option that flattens the layers
+imports one image, and Import Hidden Layers brings hidden layers in. `document.open` does the same, with
+`layers: false` for the single image and `hiddenLayers: true` for the hidden layers. The page also merges
+adjustment layers, layers with a knockout option, and layers that hold transparent pixels in some blend modes with
+the layers below them. `document.open` applies neither adjustments nor knockouts, and it merges a layer by its blend
+mode alone, as the rules below say.
+
+The rest are VectorCraft's own rules:
+
+- Each layer becomes a layer of the document holding its pixels as an image, with the layer's name, visibility,
+  opacity and blend mode.
+- A layer group becomes a layer of sublayers. A Pass Through group is not isolated; a group in any other mode is.
+- Layers clipped to the layer below are merged into it as one image, shown where that layer has pixels. Layers
+  clipped to an adjustment layer, or to a fill layer that stores no pixels and isn't drawn, show over the whole
+  canvas, through that layer's mask.
+- Hidden layers are left out unless `hiddenLayers: true`, which brings them in hidden. A hidden layer that would
+  need a merge is always left out, with the layers clipped to it. The `warnings` count the layers left out.
+- `layers: false` opens the merged image.
+- A layer or group in Dissolve, Linear Burn, Linear Dodge, Vivid Light, Linear Light, Pin Light, Hard Mix, Subtract,
+  Divide, Darker Color or Lighter Color is merged with the visible layers below it in its group, whether or not it
+  holds transparent pixels. Layers in Color Dodge, Color Burn and Difference keep their mode. In such a merge, the
+  layers of a Pass Through group blend with the layers below the group, at the group's opacity and through its layer
+  mask.
+- A Dissolve layer's partly transparent pixels are merged as opaque or transparent, opaque at the share of its
+  pixels their transparency gives, in a fixed pattern that differs from layer to layer.
+- A merged layer is named after the layers it holds, joined with ` + `.
+- A layer name the file stores only as a one-byte Pascal string, without its Unicode name, is read as Mac Roman.
+- A layer's opacity is multiplied by its fill opacity, in every blend mode. A layer that others are clipped to keeps
+  its own opacity, and its fill opacity fades only its own pixels.
+- A layer mask becomes the layer's opacity mask: a gray image that hides the layer outside it when the mask's
+  default color is black and shows it when white. A disabled mask is kept, switched off.
+- Type and shape layers, and gradient and pattern fill layers that store pixels, come in as the pixels the file
+  stores. A solid color fill layer that stores no pixels and has no vector mask comes in as an image of its color
+  (RGB, CMYK, Grayscale, Lab or HSB) over the canvas. One whose shape is a vector mask isn't drawn, and the layers
+  clipped to it are left out.
+- Adjustment layers, fill layers that store no pixels and whose fill isn't read, layer effects that are switched on,
+  knockouts and vector masks are not applied; the `warnings` count them.
+- Layer channels may be raw, PackBits or zipped (with or without prediction) at 8, 16 and 32 bits.
+- A file without layers opens as its merged image. A file whose layers can't be read opens as its merged image
+  with a warning, and when the merged image can't be read either, the file is refused with an error.
+
+Each layer's pixels must fit the memory allowed for one image, and the pixels of all the layers and masks, with the
+canvases the merges make, must together fit eight times that; a file past either limit opens as its merged image,
+with a warning. The canvases one step of a merge holds at once must also fit the memory allowed for one image; when
+they don't, the layer that needed the merge comes in alone, with a warning: in the Normal mode, or as a layer of its
+own instead of clipped. File › Open in the app has no PSD import options dialog: it converts the layers and leaves
+hidden layers out.
+
+```json
+{"name":"run_command","arguments":{"command":"document.open","params":{"path":"/tmp/poster.psd","hiddenLayers":true}}}
+```
+
 JPEG XL images (`.jxl`, a bare codestream or the ISOBMFF container) open and place as their first frame, with the
 orientation their header gives, decoded with jxl-oxide and stored as PNG. 16-bit and floating-point samples become 8
 bits, and alpha is kept. Colors are converted to sRGB in XYB-encoded images and when the header names the color space
@@ -1462,6 +1462,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur
    EPS export writes a linear or radial gradient of tints of one spot color (and paper white) in that ink's Separation space, at Level 2 and 3, and at Level 3 one that mixes a spot color with process or gray colors, or two spot colors, in a DeviceN space of the spot inks and the process inks its stops use, so each spot ink prints on its own plate; an off-center midpoint is written as a stop with the inks halfway between its two stops. At Level 2, such a mix is written in process colors with a warning. In an RGB export, a gradient that mixes a spot color with RGB or Lab colors is written without the spot ink, with a warning; a CMYK export converts those stops to CMYK first, and the gradient follows the rules above. A Perceptual gradient of spot colors, and a mix whose DeviceN space would need more than 32 inks or a spot color named Cyan, Magenta, Yellow or Black, are also written in process colors with a warning (`crates/eps/src/tests.rs`). A spot color named All or None (in a Separation space, the names of every plate and of no plate: [ISO 32000-1:2008](https://opensource.adobe.com/dc-acrobat-sdk-docs/pdfstandards/PDF32000_2008.pdf), 8.6.6.4), is written as the ink All Spot or None Spot (All Spot 2 and on when a spot swatch already has that name) in its fills, strokes, gradients and DSC comments; Registration still prints on every plate (`tests::spot_inks_named_all_or_none_are_written_under_names_of_their_own`).
  - Targa files (`.tga`, `.vda`, `.icb`, `.vst`) open, place linked or embedded, relink and update at their pixel size: color-mapped, true-color and black-and-white, raw or run-length encoded, in any of the four row orders. The image descriptor's attribute bits and the extension area's Attributes Type decide the transparency: a file with no attribute bits, or with attribute data the Attributes Type calls undefined, opens opaque; with one bit, a 16-bit true-color pixel takes that bit as its alpha, and a color-mapped pixel takes the bit of the 16-bit color map entry it indexes; premultiplied colors are divided by their alpha. Open and Place recognize a Targa file by its extension, and `clipboard.importImage` and Glass's Load Texture… by its header; a Targa file copied in a file manager pastes as a bitmap (`crates/engine/src/cmd/fileio/tests_tiffbmp.rs`, `crates/engine/src/tests/links.rs`).
  - BMP files named `.dib` or `.rle` (run-length encoded bitmaps included), Photoshop files named `.pdd` and PNG files named `.pns` open and place, linked or embedded, as BMP, PSD and PNG files, in any letter case: the Open and Place dialogs list them with their format, the Links panel names their format, and Edit Original opens them. Exports write only `.bmp`, `.psd` and `.png` (`crates/engine/src/cmd/fileio/tests_tiffbmp.rs`, `crates/engine/src/cmd/fileio/tests_psdread.rs`, `crates/engine/src/tests/links.rs`).
+  - File › Open converts a PSD or PSB file's layers to objects, keeping the layer structure, merging clipped layers into one layer and leaving out hidden layers that would need a merge, as [PSD import options](https://helpx.adobe.com/illustrator/desktop/add-and-import-files/import-from-other-apps/photoshop-import-options.html) describes for the option that converts layers to objects; hidden layers come in with `hiddenLayers`, as Import Hidden Layers brings them in, and `layers: false` opens the merged image. VectorCraft's own rules: each layer becomes a layer holding its pixels with its name, visibility, opacity and blend mode, groups become layers of sublayers, layers in Dissolve, Linear Burn, Linear Dodge, Vivid Light, Linear Light, Pin Light, Hard Mix, Subtract, Divide, Darker Color and Lighter Color are merged with the layers below, layer masks become opacity masks, fill opacity multiplies the opacity (in a layer that others are clipped to, it fades only that layer's own pixels), and adjustment layers, layer effects, knockouts and vector masks aren't applied and are counted in the warnings. 8-, 16- and 32-bit files, PSB, raw, PackBits and zipped channels. There is no PSD import options dialog yet (`crates/engine/src/cmd/fileio/tests_psdlayers.rs`).
  - PCX files (`.pcx`) open and place, from the ZSoft PCX Technical Reference Manual: 1 bit in the header palette's first two colors (black and white when the version has no palette or both colors are the same), 1 bit in two to four planes and 4 bits with up to 16 colors from the header's palette (the EGA colors for versions 0 and 3), 2 bits in the CGA colors that the header's CGA palette settings pick (background, color burst, palette and intensity), 8 bits with the 256-color palette after the image data (gray levels without one) and 24-bit color in three planes, run-length encoded. The header's HDpi and VDpi size the image. A file of another depth or plane count, one cut short, and one whose pixels as RGBA pass the pixel allowance are refused with a message before its pixels are decoded. Open and Place recognize a PCX file by its extension, and `clipboard.importImage` and Glass's Load Texture… by its header; a PCX file copied in a file manager pastes as a bitmap (`crates/engine/src/cmd/fileio/tests_pcxread.rs`).
  - Pixar picture files (`.pxr`) open, place and paste, from "The Format of Stored Pictures" in the Pixar Image Computer manuals: any set of the R, G, B and A channels in 8 or 12 bits, dumped or run-length encoded with all four packet kinds and block ends, in tiles of any size (pixels of border tiles past the picture are dropped). R alone is gray, a missing color channel is 0 and a missing A opaque; 12-bit samples are clamped to 0.0 to 1.0; color matted to black becomes straight color; a null tile is transparent when the picture has A and black otherwise. The offsets aren't read, and the image takes the default resolution. Version 2 headers read like version 0. A file cut short, one with a tile whose writing wasn't finished, one with header values or packets the format doesn't define, and one whose pixels as RGBA pass the pixel allowance are refused with a message. Every reader recognizes a Pixar file by its magic number. Tested on synthetic files only (`crates/engine/src/cmd/fileio/tests_pxrread.rs`).
  - JPEG 2000 JP2 and raw codestream images open and place from `.jpf`, `.jpx`, `.jp2`, `.j2k`, `.j2c` and `.jpc`. Each axis uses the valid display resolution (`resd`), else the valid capture resolution (`resc`), whichever box comes first ([ITU-T T.800](https://www.itu.int/rec/T-REC-T.800/en), I.5.3.7.2); an axis with none uses 72 ppi. Multiple codestreams, JPX composition or layers, and unsupported color spaces are refused with a message. The decoder checks image size before allocating (`crates/engine/src/cmd/fileio/tests_jp2read.rs`).