Fix #381: round single corners with Direct Selection (per-corner Live Corners)

A live rectangle stored four corner radii but drew them all with the largest,
and the corner widgets always rounded all four corners, so one corner could not
be rounded on its own.

- geom: rectangle_with_corners draws each corner with its own radius and kind
  (Round, Inverted Round, Chamfer); a sharp corner is one anchor, a cut one two.
  Uniform corners keep the exact rounded-rectangle anchors.
- doc: LiveShape::Rectangle gains `kinds` (saved only when a corner isn't round;
  older files read as round), plus helpers mapping anchors to corners.
- engine: object.setLiveShape takes `corners` and `kind`; without `corners` it
  edits the Direct-Selected corners, else all four, and keeps the selected
  corners selected as their anchors change.
- tools: with Direct Selection, only the selected corners show widgets and a
  drag rounds just those; Alt-click cycles the corner kind; double-click opens
  the new Corners dialog (also `ui.corners`).
- ui: Properties/Transform radius fields show and set the selected corners;
  CSS export keeps per-corner radii and skips cut-in corners.
- docs: mcp.md (Live Corners), control-protocol.md (Corners dialog), ROADMAP.

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

Cargo.lock

@@ -4332,13 +4332,16 @@ name = "vectorcraft-doc"
 version = "0.4.0"
 dependencies = [
  "image",
+ "jpeg-encoder",
  "kurbo 0.13.1",
  "proptest",
  "serde",
  "serde_json",
  "thiserror 2.0.21",
+ "tiff",
  "vectorcraft-color",
  "vectorcraft-geom",
+ "zune-jpeg",
 ]
 
 [[package]]
@@ -4484,6 +4487,7 @@ dependencies = [
  "hayro-interpret",
  "hayro-syntax",
  "image",
+ "jpeg-encoder",
  "krilla",
  "kurbo 0.13.1",
  "log",

Cargo.toml

@@ -62,6 +62,10 @@ linesweeper = "0.4"
 flate2 = { version = "1", default-features = false, features = ["rust_backend"] }
 jpeg-encoder = { version = "0.6", default-features = false, features = ["std"] }
 gif = { version = "0.14", default-features = false, features = ["std", "raii_no_panic"] }
+# CMYK image samples (vectorcraft-doc's cmyk module): the image crate's own TIFF and JPEG
+# decoders, read directly (the image crate converts CMYK to RGB).
+tiff = "0.11"
+zune-jpeg = "0.5"
 
 # ui
 egui = "0.36"

ROADMAP.md

@@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob
 
 This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands.
 
-_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS; see [Honest assessment](#honest-assessment-2026-10-05))._
+_Last updated: 2026-10-08 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, the 2026-10-07 issue fixes, the Layers panel rework and the 2026-10-08 community contributions: Pen and shape-tool modifiers, path editing, Layers, Artboards, Swatches/Brushes and dialogs, Japanese composition and PDF text, Hebrew/Arabic type, interface languages (Spanish among them), the font menu, saved selections, MCP and EPS, the missing-font export warning (#319), open paths in the Shape Builder (#374) and PDF/`.ai` import keeping strokes live and hidden and nested layers (#372) and per-corner Live Corners (#381); see [Honest assessment](#honest-assessment-2026-10-05))._
 
 ## Where we are
 
@@ -63,7 +63,8 @@ Ordered by how much each gap blocks someone from switching. Sizes are one-agent
    spell-check dictionary (open licence), Touch Type and Snap to Glyph. Vertical point, area and path type have
    initial support. 35–48 h across type core and advanced.
 5. **Brushes, symbols and libraries:** brush options depth; original brush, symbol and graphic-style libraries
-   generated in code (never Adobe's); dynamic symbols; Start Global Edit. 14–22 h.
+   generated in code (never Adobe's); dynamic symbols; Start Global Edit; brushes driven by pen tilt, bearing and
+   barrel rotation (6D art pens, #372), which needs tablet input beyond pressure on every platform. 20–32 h.
 6. **Automation:** Variables (data merge), a scripting surface over the command registry, batch. 8–12 h.
 7. **Views and windows:** multiple windows and arrange, Consolidate All Windows, video
    rulers. 15–25 h.
@@ -112,14 +113,14 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools. Space held while dragging out a shape, line, arc, spiral or grid moves it at its current size. While a grid is dragged out, Up/Down change its rows (concentric dividers) and Left/Right its columns (radial dividers).
   - **Cutting:** Eraser, Scissors, Knife, Mirror & Cut, Line Cut and Rectangle Cut (real geometry, compound paths keep their holes).
   - **Transform:** Rotate, Reflect, Scale, Shear (click or Alt-click snaps the reference point to anchors and centres; Alt-click opens the tool's dialog, and a drag with Alt down at the release, from the press or pressed mid-drag, transforms a copy), Reshape, Free Transform (free and perspective distort and shear, switched by the keys held during a handle drag).
-  - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout. Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them.
+  - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout; with Direct Selection, select corner anchors to show and round just those corners (#381). Each corner keeps its own radius and kind (Round, Inverted Round, Chamfer): Alt-click a widget to cycle the kind, double-click it for the Corners dialog, and the Properties and Transform radius fields set the selected corners (`object.setLiveShape {corners, radius, kind}`). Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them.
   - **Pen:** Alt pressed in the middle of dragging out an anchor splits its handles and keeps the curve already shaped into it (only the outgoing handle follows the pointer); Space held while dragging out an anchor moves it, handles and all. Clicking the last anchor of the path being drawn retracts its outgoing handle (convert cursor), and dragging from it pulls out a new one on its own. Auto Add/Delete: over a selected path, a click on a segment adds an anchor and a click on an anchor deletes it (add and delete cursors); Shift held, or Preferences › General › Disable Auto Add/Delete, starts a new path instead.
   - **Graphs:** Column, Stacked Column, Bar, Stacked Bar, Line, Area, Scatter, Pie and Radar graph tools with Graph Data and Graph Type.
   - **Other:** Eyedropper, Gradient annotator, Artboard (Alt-drag duplicates an artboard, and its art with Move/Copy Artwork with Artboard on), Measure, Type, Hand, Zoom, Rotate View.
   - **Editing type:** double-clicking type with a selection tool switches to the Type tool with the caret where it was clicked.
   - **Temporary tools:** Cmd with any other tool drags with the selection tool used last (Selection, Direct Selection or Group Selection). Held Space pans and Cmd+Space zooms (Cmd+Alt+Space out) whatever the tool.
   - **Panel drag and drop:** art dragged off the canvas onto the Symbols panel becomes a symbol, onto the Swatches panel a pattern swatch and onto the Brushes panel an Art brush; a symbol dragged onto the canvas places an instance where it is dropped, and a brush dragged onto a path is applied to it.
-  - **Tool double-clicks:** double-clicking a tool's button opens its options: Hand fits the artboard in the window, Zoom shows 100 %, Rotate, Scale, Reflect and Shear open their Object › Transform dialogs, Gradient, Eyedropper, Blend and the Liquify tools their panels or options.
+  - **Tool double-clicks:** double-clicking a tool's button opens its options: Hand fits the artboard in the window, Zoom shows 100 %, Rotate, Scale, Reflect and Shear open their Object › Transform dialogs, the Selection, Direct Selection and Group Selection tools the Move dialog (Enter opens these seven tools' dialogs too), Gradient, Eyedropper, Blend and the Liquify tools their panels or options.
 - **Layers panel:** every layer, sublayer, group and object is a clickable row at any depth: a click highlights it and makes its layer current (new art goes there), Shift-click a range, Ctrl/Cmd-click toggles. Sublayers are no longer treated as objects: clicks, marquees, Select All and the Select menu take the art inside them, and each sublayer selects in its own colour. Selection squares on rows with selected art (click selects a row's art, Shift adds or removes; dragging the square moves the selection to another row, Alt copies), the eye and lock on every row with drag-down-the-column (one undo step), Ctrl/Cmd-click an eye for per-layer Outline, Alt-click an eye or lock to hide or lock the other layers (again: show or unlock them all), triangles with Alt to open or close everything inside, drag and drop rows above, below or into layers and groups with a drop line (Alt copies, the trash deletes), inline rename, Delete key on highlighted rows. Buttons and the full panel menu: New Layer/Sublayer (Alt: options, Ctrl: on top), Duplicate, Delete, Options for Selection, clipping mask, isolation, Locate Object, Merge Selected, Flatten Artwork, Collect in New Layer, Release to Layers (Sequence and Build), Reverse Order, Template, Hide/Outline/Lock Others and Show/Preview/Unlock All, Paste Remembers Layers, Panel Options (row size, thumbnails per kind, Show Layers Only). Layer Options: name, colour (presets or custom), Template, Lock, Show, Print, Preview (outline drawing and clicking) and Dim Images to %. Every operation is a command (`layer.move`, `layer.highlight`, `layer.merge`…) with validation against cycles and invalid nesting.
 - **Drawing aids:** Smart Guides and snapping (moving, and resizing by the bounding-box handles: the dragged edges align with the other objects; the Artboard tool snaps artboards, and their bleed, to other artboards, bleeds and art, the grid or whole pixels while moving, copying and resizing them, and the Transform panel shows and edits the active artboard's X/Y/W/H), guides dragged out of the rulers, and Draw Normal / Behind / Inside modes.
 - **Views:** the status bar's artboard navigator (first, previous, next, last; `view.goToArtboard`) goes to an artboard and fits it, and Fit Artboard in Window and Actual Size show the navigator's artboard. The Artboards panel highlights that active artboard: clicking a row makes it active (the Artboard tool's too, while it is chosen) as does clicking an artboard with the Artboard tool, double-clicking its number also fits it in the window and double-clicking its name renames it.
@@ -127,9 +128,9 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - Pathfinder (10 exact curve booleans), Offset, Outline Stroke, Simplify, Clean Up, Split Into Grid, Divide Objects Below. Object › Path › Remove Anchor Points (`path.removeAnchors`) removes the direct-selected anchors without opening their paths (the Delete key still deletes them with their segments): the neighbours keep their handle directions and their facing handles are refitted so one cubic follows the two old segments, and straight sides stay straight. The Delete Anchor Point tool uses the same refit. The Control bar, the contextual task bar, the Properties quick actions and the canvas context menu offer it when anchors are selected.
   - Live effects with previewing dialogs: Distort & Transform, Path, Convert to Shape, 15 Warp styles, Round Corners, Scribble, Effect → Pathfinder (all 10 operations, live on groups; several loose objects are grouped first, in one undo step), Color Adjustments (Brightness/Contrast, Curves, Levels, Hue/Saturation, Shift to Color, Temperature/Tint, on vectors, live type and embedded images), and raster drop shadow, glows and feather. SVG and PDF export keep live effects (geometry baked; SVG raster effects as filters).
 - **Type:** Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity), Character and Paragraph Styles (override-preserving redefine), Area Type Options (rows/columns/inset/first baseline), threaded text across any closed shapes, Fit Headline. Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`). Point type still scales. Variable fonts list every named instance as a style of their family (Figtree Light to Black and their italics, Bahnschrift, Segoe UI Variable), and the instance chosen is shaped, drawn, outlined and measured at its axis settings; PDF and SVG embed it as that instance. Variation axis sliders are not done. Hebrew and Arabic are laid out right to left with the Unicode bidirectional algorithm (embedded Latin and numbers keep their direction, lines put in visual order after wrapping) in point, area and path type, with caret, selection and arrow keys in visual order; each paragraph's direction comes from its first strong character unless Paragraph Direction sets it (Paragraph panel with Show Indic Options, `text.setFormat {direction}`), and new type aligns to the start of its direction. SVG export outlines right-to-left text.
-- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese and Spanish (neutral international Spanish, for every `es-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech and Spanish ones from the bundled UI fonts. The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width, and puts a quarter em between Japanese and Latin letters or digits; Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines.
+- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional and Simplified Chinese, Japanese and Spanish (neutral international Spanish, for every `es-*` locale) cover the whole interface, Czech and Brazilian Portuguese every menu label, Brazilian Portuguese the shell's `tl!` literals too (tested); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech and Spanish ones from the bundled UI fonts. The Basic toolbar's Type button holds Vertical Type in its flyout. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese, and justified Japanese lines spread their room between characters (not inside Latin words); Paragraph panel › Mojikumi Set (shown with Preferences › Type › Show East Asian Options, `text.setFormat {mojikumi}`): None or Line-end Punctuation Half Width (new type's default, as in Illustrator; older documents and imported text keep None) shares one half-em space between consecutive punctuation, sets a closing mark ending a line half width, and puts a quarter em between Japanese and Latin letters or digits; Paragraph panel menu › Top-to-Top / Bottom-to-Bottom Leading measures leading from em box top to top (area type's first line touches the frame) or from baseline to baseline; Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines.
 - **Transparency:** opacity masks (clip/invert/disable/link), exported as SVG `<mask>` and PDF soft masks.
-- **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder, Live Paint (every path an edge, open lines included), Image Trace (12 presets), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror).
+- **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type (choosing a perspective tool shows the grid; Hide Grid hides it with the tool still chosen), Gradient Mesh, Shape Builder (stroke-only open paths and lines cut the regions they cross and enclose regions of their own; Alt deletes their pieces; filled open paths count as closed), Live Paint (every path an edge, open lines included), Image Trace (12 presets), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror).
 - **Paint and appearance (M3):**
   - **Swatches:** names follow the colour model and are unique; Swatch Options (process/spot, Global, Gray/RGB/HSB/CMYK/Web, live preview); editing a global or spot swatch recolours every linked fill, stroke and text run in one undo step; multi-select and delete with confirmation; New Swatch and New Color Group dialogs (a group from the selected artwork's colours); swatches in colour groups convert, separate and count like any other. The Swatches panel selects ranges and whole groups, has a find field, and drags swatches to reorder, regroup or paint art; Add Used Colors, Select All Unused, Merge, Ungroup and Sort by Kind; a CMYK document keeps applied colours in CMYK. Swatch libraries: nine generated colour libraries and five gradient libraries in a library panel, saved and loaded as `.vcswatches`, `.gpl` or CSS. Tints of global and spot colours ("Name 40%") stay linked and separate as a percentage of their plate. Spot colours can be defined in Lab (Spot Colors options). A built-in [Registration] swatch prints on every plate.
   - **Colour:** a Color Picker (colour field, H/S/B/R/G/B channel slider, HSB/RGB/Lab/CMYK fields, hex, web-only snapping, out-of-gamut correction); the Color panel follows each colour's own model and Alt-click paints the other proxy; proxies look through groups and show "?" for mixed paint; Invert, Complement, Apply Last Color (`,`) and Apply Last Gradient (`.`) keep the colour model; every paint command feeds the recent colours. The Color Guide has 21 harmony rules, Steps and Variation options and Limit to Library. Adjust Color Balance (its Global mode shifts tints) and Saturate preview live; Edit Colors and Recolor also reach meshes, images and patterns. Recolor Artwork has colour reduction, five recolour methods, presets, Limit to Library, a colour-wheel Edit tab and Edit Color Group; a local Color Themes panel saves five-colour themes. Fill/Stroke chips open swatch and mixer popovers, panels have their shortcuts, and Eyedropper Options pick up and apply chosen attributes (Alt and Shift+Alt, image pixels). Fills and strokes can overprint (Attributes panel, Overprint Black options), and CMYK documents blend in inks on screen, in PDF and when flattening.
@@ -141,10 +142,10 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - **Graphic styles:** styles keep opacity and blend mode, capture groups and type, apply on top with Alt, and link to the objects using them; Redefine, Break Link, Graphic Style Options, Select All Unused, Sort by Name, and Select > Same Graphic Style / Appearance Attribute. The panel has list and thumbnail views with rendered previews, merge, reorder and drag and drop, plus a Control bar Style picker; six generated style libraries save and load as `.vcstyles`.
   - **Neutral wording:** labels, MCP tool text, docs and packaging use neutral names, and `cargo xtask brands` (part of `cargo xtask ci`) fails on vendor names.
 - **Colour, type and file workflows:** Recolor Artwork (dialog with harmonies), Edit Colors, Find & Replace, Change Case, Smart Punctuation, Guides, Lock/Hide Above, Transform Each, Rasterize.
-- **Fonts:** a font is found by any of its names (family and style in every language of its name table, legacy family/style pairs, PostScript name), so documents from other apps open with the font they name; Find Font and `text.fonts` say for each font whether it was found exactly, by another name, substituted or missing, and how many glyphs are missing. PDF and `.ai` import brings Japanese text back as live type: CID fonts without a ToUnicode map read through the standard CMaps, vertical columns (WMode 1) as vertical type, letter spacing as tracking; a glyph is live type only when the installed font (in the closest style of its family) draws the same glyph, and text in a font that isn't installed comes in as live type shown in the fallback font until the font is installed.
+- **Fonts:** a font is found by any of its names (family and style in every language of its name table, legacy family/style pairs, PostScript name), so documents from other apps open with the font they name; Find Font and `text.fonts` say for each font whether it was found exactly, by another name, substituted or missing, and how many glyphs are missing. PDF and `.ai` import brings Japanese text back as live type: CID fonts without a ToUnicode map read through the standard CMaps, vertical columns (WMode 1) as vertical type, letter spacing as tracking; a glyph is live type only when the installed font (in the closest style of its family) draws the same glyph, and text in a font that isn't installed comes in as live type shown in the fallback font until the font is installed (exports that draw it — PDF, EPS, EMF/WMF, raster, SVG outlines or embedded fonts — warn that they wrote the fallback font; `textAs: outlines` keeps the PDF's embedded glyphs).
 - **Files (M4):**
-  - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash, background save and export.
-  - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units; PDF and PDF-compatible `.ai` in and out (layers, masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, an `.ai`'s white page under its layers left out rather than coming in as art, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3).
+  - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash (browser tabs hold their copies with Web Locks too, so a background tab's copies are never taken for a crash's, and a tab repairs copies another removed when it resumes: #367), background save and export.
+  - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units; PDF and PDF-compatible `.ai` in and out (layers, with hidden ones kept hidden with their art and nested ones as sublayers; strokes kept live, a fill and a stroke of one outline as one object; masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, an `.ai`'s white page under its layers left out rather than coming in as art, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3). CMYK images keep their ink amounts from PDF import (and from placed CMYK TIFFs) to PDF export: a CMYK JPEG passes through unchanged, others stay CMYK (DeviceCMYK, or ICC-based CMYK in PDF/X-3/X-4) unless the Output settings convert them; the canvas shows them through the working CMYK profile (#320).
   - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs Illustrator's AGM/CoolType prologs (resource categories, `resourceforall`, `clipsave`/`cliprestore`, subarrays and substrings that share storage, the standard dictionaries in `systemdict`, `dictstack`, `internaldict`, executable filters, `cshow`, metadata skipped with `flushfile`), so Illustrator 30 EPS files open as vectors, and falls back to its palette TIFF preview. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole).
   - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours.
 - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped.
@@ -157,11 +158,11 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 |---|---|---|---|
 | M0 | Skeleton + vertical slice | ✅ done | — |
 | M1 | Selection, transform, layers, MCP | ✅ mostly done (transform reference point snaps to anchors/centres; rotated objects keep a rotated bounding box and their angle; Free Transform, Scale and Reflect along a rotated box pending) | 4–6 |
-| M2 | Drawing tools + smart guides | ✅ mostly done (Flare, Reshape, Live Corners widget dragging landed; Shaper, the remaining Pen modifier nuances) | 15–20 |
+| M2 | Drawing tools + smart guides | ✅ mostly done (Flare, Reshape, Live Corners widget dragging and per-corner radii and kinds landed; Shaper, the remaining Pen modifier nuances) | 15–20 |
 | M3 | Paint & appearance (swatches, color, gradient, stroke, appearance, transparency, styles) | ✅ done (M3.7–M3.98): swatches, groups, libraries, tints, Lab spots and Registration; Color Picker, Color panel, Color Guide, Color Themes, Edit Colors and Recolor Artwork; gradients that follow every transform, the annotator, linked stops, freeform gradients, focal points, gradients on strokes and Expand; stroke geometry, arrowheads, dashes fitted to corners, stroke on type, width profiles and the Width tool, Scale Strokes and preview bounds; Appearance targeting, container appearance, target circles, Expand Appearance; knockout, isolation, blend accuracy, CMYK blending, overprint, Attributes, masks and clipping, Flatten Transparency; graphic styles, links and libraries. Left: freeform and mixed spot/process gradients export as stops or process colours to SVG/PDF; confirm the Scale Strokes & Effects default | 4–8 |
 | M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | ✅ done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3), Place and Links, Package, EPS and DXF in and out, EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, Asset Export, clipboard flavours, File Info. Left: DWG (use DXF), PSD placement as layers, overprint read back from PDF, polish | 3–6 |
 | M5 | Performance | 🟡 background render + caches + MT done; `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 |
-| M6 | Path operations (Pathfinder, Shape Builder, offset…) | ✅ mostly done (Boolean precision on almost-horizontal edges fixed and the property tests made deterministic; Shape Builder edge erase, large-offset bug open) | 3–6 |
+| M6 | Path operations (Pathfinder, Shape Builder, offset…) | ✅ mostly done (Boolean precision on almost-horizontal edges fixed and the property tests made deterministic; Shape Builder gap detection, large-offset bug open) | 3–6 |
 | M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options (with Width/Height), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (searchable; the Character and Properties menus show each family's sample of the selected text, preview it live under the pointer or ↑/↓, filter by script and kind, list a family's styles, and star favourites) and found by name on open/import, variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects, tab stops + Tabs panel, Hebrew/Arabic bidirectional text and Paragraph Direction done; tab leaders, spell check, vertical type pending | 45–60 |
 | M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 |
 | M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder and Color Adjustments; SVG Filters, Document Raster Effects Settings, 3D pending | 86–135 |
@@ -189,10 +190,10 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 | Area | Weight | Done | Missing (main items) | One agent (h) |
 |---|---:|---:|---|---:|
 | Selection, transform & align tools | 6 | 85% | Free Transform/Scale/Reflect along a rotated box, Start Global Edit, transform nuances (the rotated persistent bounding box is done) | 4–6 |
-| Drawing tools | 7 | 85% | Shaper Groups (merge/punch overlapping shapes), pencil and the remaining pen modifier nuances, Touch Type | 10–15 |
-| Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 86% | Live Paint gap options, Shape Builder edge cases | 3–6 |
+| Drawing tools | 7 | 85% | Shaper Groups (merge/punch overlapping shapes), pencil and the remaining pen modifier nuances, Touch Type, Live Corners on plain paths and polygons (and Relative rounding) | 10–15 |
+| Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 86% | Live Paint gap options, Shape Builder gap detection and options | 3–6 |
 | Colour, swatches, gradients, patterns, mesh, recolor | 7 | 96% | freeform and mixed spot/process gradients in SVG/PDF (exported as stops or process colours), pattern fills in Expand | 2–4 |
-| Strokes, brushes, width profiles | 5 | 88% | brush options depth, brush libraries (generated in code) | 6–10 |
+| Strokes, brushes, width profiles | 5 | 88% | brush options depth, brush libraries (generated in code), brushes driven by pen tilt, bearing and barrel rotation (6D art pens) | 12–20 |
 | Appearance, transparency, graphic styles, masks | 5 | 98% | raster effect reach in preview bounds (flattener presets apply in PDF, EPS and print) | 1–2 |
 | Live vector effects | 5 | 85% | Outline Object, Pathfinder Hard/Soft Mix and Trap, SVG Filters | 6–10 |
 | Raster effects (Effect Gallery, Document Raster Effects Settings) | 4 | 20% | ~55 Photoshop-style filters (Artistic, Brush Strokes, Distort, Pixelate, Sketch, Stylize, Texture, Video) and the Effect Gallery; Document Raster Effects Settings and raster effects in PDF are done | 28–42 |

apps/vectorcraft-web/Cargo.toml

@@ -27,4 +27,4 @@ rfd = { workspace = true }
 wasm-bindgen = "0.2"
 wasm-bindgen-futures = "0.4"
 js-sys = "0.3"
-web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlIFrameElement", "HtmlAnchorElement", "Blob", "BlobPropertyBag", "Url", "Location", "CssStyleDeclaration", "Event", "EventTarget", "MouseEvent", "DragEvent", "Storage"] }
+web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlIFrameElement", "HtmlAnchorElement", "Blob", "BlobPropertyBag", "Url", "Location", "CssStyleDeclaration", "Event", "EventTarget", "MouseEvent", "DragEvent", "Storage", "Navigator"] }

apps/vectorcraft-web/src/locks.rs

@@ -0,0 +1,122 @@
+//! The browser's Web Locks (`navigator.locks`), which tell Data Recovery whether another tab still
+//! runs ([`vectorcraft_engine::cmd::recovery::RecoveryStore::announce`]). A tab holds a lock named
+//! after its recovery area for as long as it lives; the browser releases it only when the tab is
+//! gone (closed, crashed or reloaded), not while its timers are paused in the background, which a
+//! heartbeat can't tell apart.
+//!
+//! web-sys has Web Locks only as an unstable API, so they are reached through `js_sys::Reflect`.
+//! Pages that aren't secure (plain `http://` other than localhost) and older browsers have none:
+//! heartbeats alone decide there.
+
+use std::cell::RefCell;
+use std::collections::{BTreeMap, BTreeSet};
+use std::sync::{Arc, Mutex};
+
+use js_sys::{Function, Promise, Reflect};
+use vectorcraft_engine::cmd::recovery::Hold;
+use wasm_bindgen::JsCast as _;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::closure::Closure;
+
+/// How often the snapshot of the locks held is refreshed (ms).
+const REFRESH_MS: i32 = 10_000;
+/// How old a snapshot may be and still be trusted (ms). A lock asked for after the snapshot was
+/// taken comes with a heartbeat, which stays fresh for at least three minutes, so anything under
+/// that is safe; an older snapshot counts every area as held.
+const FRESH_MS: f64 = 60_000.0;
+
+thread_local! {
+    /// What releases each lock this tab holds, by name: it resolves the promise the lock is held
+    /// by (wasm runs on one thread).
+    static RELEASE: RefCell<BTreeMap<String, Function>> = const { RefCell::new(BTreeMap::new()) };
+}
+
+/// The locks of the page, named `<prefix><area>`.
+#[derive(Clone)]
+pub struct WebLocks {
+    prefix: &'static str,
+    /// The areas whose locks were held at the last snapshot, and when it was asked for (ms since
+    /// the epoch). `navigator.locks.query()` is asynchronous, so the snapshot is refreshed every
+    /// [`REFRESH_MS`] and read from here.
+    seen: Arc<Mutex<(f64, BTreeSet<String>)>>,
+}
+
+/// `navigator.locks`, if the browser has it here.
+fn manager() -> Option<JsValue> {
+    let locks = Reflect::get(&web_sys::window()?.navigator(), &"locks".into()).ok()?;
+    locks.is_object().then_some(locks)
+}
+
+/// Method `name` of `obj`.
+fn method(obj: &JsValue, name: &str) -> Option<Function> {
+    Reflect::get(obj, &name.into()).ok()?.dyn_into().ok()
+}
+
+impl WebLocks {
+    /// The page's Web Locks with a first snapshot of them, kept fresh from then on; `None` when
+    /// the browser has none or won't say which are held (heartbeats alone decide then).
+    pub async fn start(prefix: &'static str) -> Option<Self> {
+        let locks = Self { prefix, seen: Arc::new(Mutex::new((f64::NEG_INFINITY, BTreeSet::new()))) };
+        locks.refresh().await?;
+        let again = locks.clone();
+        let tick = Closure::<dyn FnMut()>::new(move || {
+            let locks = again.clone();
+            wasm_bindgen_futures::spawn_local(async move {
+                // A failed refresh leaves the snapshot to age, and every area counts as held.
+                let _ = locks.refresh().await;
+            });
+        });
+        web_sys::window()?.set_interval_with_callback_and_timeout_and_arguments_0(tick.as_ref().unchecked_ref(), REFRESH_MS).ok()?;
+        // The timer lives as long as the page.
+        tick.forget();
+        Some(locks)
+    }
+
+    /// Take a new snapshot of the locks held.
+    async fn refresh(&self) -> Option<()> {
+        let m = manager()?;
+        let asked = js_sys::Date::now();
+        let query: Promise = method(&m, "query")?.call0(&m).ok()?.dyn_into().ok()?;
+        let snapshot = wasm_bindgen_futures::JsFuture::from(query).await.ok()?;
+        let held = js_sys::Array::from(&Reflect::get(&snapshot, &"held".into()).ok()?);
+        let areas = held
+            .iter()
+            .filter_map(|l| Reflect::get(&l, &"name".into()).ok()?.as_string())
+            .filter_map(|n| n.strip_prefix(self.prefix).map(str::to_string))
+            .collect();
+        *self.seen.lock().unwrap_or_else(|e| e.into_inner()) = (asked, areas);
+        Some(())
+    }
+
+    /// Does a tab hold `area`'s lock? Yes when the last snapshot is too old to tell.
+    pub fn held(&self, area: &str) -> bool {
+        let seen = self.seen.lock().unwrap_or_else(|e| e.into_inner());
+        js_sys::Date::now() - seen.0 > FRESH_MS || seen.1.contains(area)
+    }
+
+    /// Hold `area`'s lock until the returned hold is dropped (or the page goes).
+    pub fn hold(&self, area: &str) -> Option<Hold> {
+        let m = manager()?;
+        let name = format!("{}{area}", self.prefix);
+        // The lock is held until this promise resolves: when the hold is dropped.
+        let mut release = None;
+        let until = Promise::new(&mut |resolve, _| release = Some(resolve));
+        let release = release?;
+        let granted = Closure::once_into_js(move |_lock: JsValue| until);
+        method(&m, "request")?.call2(&m, &name.clone().into(), &granted).ok()?;
+        RELEASE.with(|r| r.borrow_mut().insert(name.clone(), release));
+        Some(Box::new(LockHold(name)))
+    }
+}
+
+/// A lock this tab holds (by name), released when dropped.
+struct LockHold(String);
+
+impl Drop for LockHold {
+    fn drop(&mut self) {
+        if let Some(resolve) = RELEASE.with(|r| r.borrow_mut().remove(&self.0)) {
+            // Resolving can't fail in a way worth reporting: the lock goes with the page anyway.
+            let _ = resolve.call0(&JsValue::NULL);
+        }
+    }
+}

apps/vectorcraft-web/src/main.rs

@@ -13,6 +13,8 @@
 //!
 //! URL query flag: `?webgl` forces the WebGL2 backend instead of WebGPU.
 
+#[cfg(target_arch = "wasm32")]
+mod locks;
 #[cfg(target_arch = "wasm32")]
 mod web;
 

apps/vectorcraft-web/src/web.rs

@@ -6,12 +6,14 @@ use std::sync::{Arc, Mutex};
 
 use vectorcraft_engine::Session;
 use vectorcraft_engine::cmd::fileio;
-use vectorcraft_engine::cmd::recovery::RecoveryStore;
+use vectorcraft_engine::cmd::recovery::{Hold, RecoveryStore};
 use vectorcraft_ui_egui::place::{DropTarget, PlaceArrival, PlaceInbox};
 use vectorcraft_ui_egui::print::{PrintJob, PrintService, Printer};
 use vectorcraft_ui_egui::{Services, VectorcraftApp};
 use wasm_bindgen::JsCast as _;
 
+use crate::locks::WebLocks;
+
 type Inbox = Arc<Mutex<Vec<(String, Vec<u8>)>>>;
 
 /// Where the pointer was over the canvas during the last file drag (CSS px from its top-left) and
@@ -33,6 +35,8 @@ pub fn start() {
             return;
         };
         let drag = track_drag(&canvas);
+        // Before the first frame, which looks for copies a crash left behind.
+        let locks = WebLocks::start(RECOVERY_PREFIX).await;
         let mut options = eframe::WebOptions::default();
         if query().contains("webgl")
             && let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup
@@ -49,7 +53,7 @@ pub fn start() {
                     }
                     let inbox: Inbox = Arc::default();
                     let place_inbox: PlaceInbox = Arc::default();
-                    let app = VectorcraftApp::new(Session::new(), services(inbox.clone(), place_inbox.clone(), cc.egui_ctx.clone()));
+                    let app = VectorcraftApp::new(Session::new(), services(inbox.clone(), place_inbox.clone(), cc.egui_ctx.clone(), locks));
                     Ok(Box::new(WebShell { app, inbox, place_inbox, drag }))
                 }),
             )
@@ -132,7 +136,7 @@ impl eframe::App for WebShell {
     }
 }
 
-fn services(inbox: Inbox, place_inbox: PlaceInbox, ctx: egui::Context) -> Services {
+fn services(inbox: Inbox, place_inbox: PlaceInbox, ctx: egui::Context, locks: Option<WebLocks>) -> Services {
     let open_inbox = inbox.clone();
     let picked = place_inbox.clone();
     let place_ctx = ctx.clone();
@@ -174,7 +178,7 @@ fn services(inbox: Inbox, place_inbox: PlaceInbox, ctx: egui::Context) -> Servic
             }
         })),
         inbox: Some(inbox),
-        recovery_store: Some(Arc::new(BrowserStore)),
+        recovery_store: Some(Arc::new(BrowserStore { locks })),
         // File → Print: the browser's print dialog.
         print: Some(Box::new(BrowserPrint)),
         ..Default::default()
@@ -183,8 +187,12 @@ fn services(inbox: Inbox, place_inbox: PlaceInbox, ctx: egui::Context) -> Servic
 
 /// Data Recovery's store on the web: the browser's local storage (kept across visits and shared by
 /// the site's tabs), each entry as base64 under [`RECOVERY_PREFIX`]`<area>/<name>`. It has no
-/// locks: each tab holds its area with a heartbeat, judged by the browser's clock.
-struct BrowserStore;
+/// locks: each tab holds its area with a heartbeat, judged by the browser's clock, and with a Web
+/// Lock named after it where the browser has them (`locks`), which a tab whose timers are paused
+/// in the background keeps.
+struct BrowserStore {
+    locks: Option<WebLocks>,
+}
 
 const RECOVERY_PREFIX: &str = "vectorcraft-recovery/";
 
@@ -220,6 +228,12 @@ impl RecoveryStore for BrowserStore {
     fn now(&self) -> Option<i64> {
         Some((js_sys::Date::now() / 1000.0) as i64)
     }
+    fn announce(&self, area: &str) -> Option<Hold> {
+        self.locks.as_ref()?.hold(area)
+    }
+    fn announced(&self, area: &str) -> Option<bool> {
+        self.locks.as_ref().map(|l| l.held(area))
+    }
 }
 
 /// Trigger a browser download of `bytes` named after the last component of `path`.

crates/color/src/cms/mod.rs

@@ -662,6 +662,60 @@ impl ProofLut {
     }
 }
 
+/// A 17⁴ CMYK → four values lookup table with quadrilinear interpolation: ink amounts to a
+/// colour (XYZ, RGB, or CMYK in another space).
+pub struct CmykLut {
+    data: Vec<[f32; 4]>,
+}
+
+impl CmykLut {
+    pub fn build(f: impl Fn([f32; 4]) -> [f32; 4]) -> Self {
+        let s = (LUT_N - 1) as f32;
+        let mut data = Vec::with_capacity(LUT_N.pow(4));
+        for c in 0..LUT_N {
+            for m in 0..LUT_N {
+                for y in 0..LUT_N {
+                    for k in 0..LUT_N {
+                        data.push(f([c, m, y, k].map(|i| i as f32 / s)));
+                    }
+                }
+            }
+        }
+        Self { data }
+    }
+
+    pub fn apply(&self, inks: [f32; 4]) -> [f32; 4] {
+        const STRIDE: [usize; 4] = [LUT_N * LUT_N * LUT_N, LUT_N * LUT_N, LUT_N, 1];
+        let p = inks.map(|v| v.clamp(0.0, 1.0) * (LUT_N - 1) as f32);
+        let i = p.map(|v| (v as usize).min(LUT_N - 2));
+        let base: usize = (0..4).map(|d| i[d] * STRIDE[d]).sum();
+        let mut out = [0.0f32; 4];
+        for corner in 0..16 {
+            let (mut w, mut at) = (1.0f32, base);
+            for d in 0..4 {
+                let t = p[d] - i[d] as f32;
+                if corner >> d & 1 == 1 {
+                    w *= t;
+                    at += STRIDE[d];
+                } else {
+                    w *= 1.0 - t;
+                }
+            }
+            if w > 0.0 {
+                for (o, v) in out.iter_mut().zip(self.data[at]) {
+                    *o += w * v;
+                }
+            }
+        }
+        out
+    }
+
+    /// [`Self::apply`] to 8-bit ink amounts, for 8-bit values.
+    pub fn apply8(&self, inks: [u8; 4]) -> [u8; 4] {
+        self.apply(inks.map(|v| v as f32 / 255.0)).map(|v| (v.clamp(0.0, 1.0) * 255.0).round() as u8)
+    }
+}
+
 // ---------- the active (process-wide) settings ----------
 
 static ACTIVE: RwLock<Option<Arc<Cms>>> = RwLock::new(None);

crates/doc/Cargo.toml

@@ -13,9 +13,12 @@ vectorcraft-geom = { workspace = true }
 vectorcraft-color = { workspace = true }
 kurbo = { workspace = true }
 image = { workspace = true }
+tiff = { workspace = true }
+zune-jpeg = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }
 thiserror = { workspace = true }
 
 [dev-dependencies]
+jpeg-encoder = { workspace = true }
 proptest = { workspace = true }

crates/doc/src/cmyk.rs

@@ -0,0 +1,188 @@
+//! CMYK images: the ink amounts of image blobs that hold CMYK samples.
+//!
+//! Two encodings hold them: a four-component JPEG, whose samples are stored inverted with Adobe's
+//! marker (the convention JPEG readers and PDF writers take a CMYK JPEG to follow), and a CMYK
+//! TIFF (8 or 16 bits, chunky, ink amounts as they are). [`ImageBlob::cmyk_tiff`] writes the
+//! latter, Deflate-compressed. Every other image decodes to RGB(A) only.
+
+use std::io::Cursor;
+
+use zune_jpeg::zune_core::bytestream::ZCursor;
+use zune_jpeg::zune_core::colorspace::ColorSpace;
+use zune_jpeg::zune_core::options::DecoderOptions;
+
+use crate::ImageBlob;
+
+/// Most pixels a CMYK image is decoded with (256 MB of samples): larger ones decode as RGB.
+pub const MAX_CMYK_PIXELS: u64 = 1 << 26;
+
+/// The ink amounts of a CMYK image: C, M, Y and K bytes per pixel, 0 is no ink.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Inks {
+    pub width: u32,
+    pub height: u32,
+    pub data: Vec<u8>,
+}
+
+impl Inks {
+    /// `data` as a `width` × `height` image; `None` when it doesn't hold that many pixels, the
+    /// image is empty or it has more than [`MAX_CMYK_PIXELS`].
+    pub fn new(width: u32, height: u32, data: Vec<u8>) -> Option<Self> {
+        let n = pixels(width, height)?;
+        (data.len() as u64 == n * 4).then_some(Self { width, height, data })
+    }
+}
+
+/// `width` × `height` when it is a CMYK image's size: not empty, at most [`MAX_CMYK_PIXELS`].
+fn pixels(width: u32, height: u32) -> Option<u64> {
+    let n = width as u64 * height as u64;
+    (n > 0 && n <= MAX_CMYK_PIXELS).then_some(n)
+}
+
+/// The number of colour components of JPEG `bytes` (its frame header); `None` when they aren't a
+/// JPEG.
+pub fn jpeg_components(bytes: &[u8]) -> Option<usize> {
+    if !bytes.starts_with(&[0xFF, 0xD8]) {
+        return None;
+    }
+    let mut d = zune_jpeg::JpegDecoder::new_with_options(ZCursor::new(bytes), DecoderOptions::default());
+    d.decode_headers().ok()?;
+    Some(d.info()?.components as usize)
+}
+
+fn is_tiff(bytes: &[u8]) -> bool {
+    bytes.starts_with(b"II*\0") || bytes.starts_with(b"MM\0*")
+}
+
+/// The colour type of TIFF `bytes` and its decoder.
+fn tiff(bytes: &[u8]) -> Option<(tiff::ColorType, tiff::decoder::Decoder<Cursor<&[u8]>>)> {
+    if !is_tiff(bytes) {
+        return None;
+    }
+    let mut d = tiff::decoder::Decoder::new(Cursor::new(bytes)).ok()?;
+    Some((d.colortype().ok()?, d))
+}
+
+impl ImageBlob {
+    /// A CMYK TIFF of ink amounts `inks` (Deflate-compressed); `None` when it can't be written.
+    pub fn cmyk_tiff(inks: &Inks) -> Option<Self> {
+        use tiff::encoder::{Compression, TiffEncoder, colortype::CMYK8, compression::DeflateLevel};
+        let mut out = Cursor::new(Vec::new());
+        TiffEncoder::new(&mut out)
+            .ok()?
+            .with_compression(Compression::Deflate(DeflateLevel::Balanced))
+            .write_image::<CMYK8>(inks.width, inks.height, &inks.data)
+            .ok()?;
+        Some(Self::new("image/tiff", out.into_inner()))
+    }
+
+    /// Does the image hold CMYK samples (a four-component JPEG or a CMYK TIFF)? Reads only its
+    /// header.
+    pub fn is_cmyk(&self) -> bool {
+        jpeg_components(&self.bytes) == Some(4) || tiff(&self.bytes).is_some_and(|(t, _)| matches!(t, tiff::ColorType::CMYK(8 | 16)))
+    }
+
+    /// The ink amounts of a CMYK image; `None` for other images, and ones that can't be decoded
+    /// or are larger than [`MAX_CMYK_PIXELS`].
+    pub fn cmyk(&self) -> Option<Inks> {
+        let bytes = self.bytes.as_slice();
+        if bytes.starts_with(&[0xFF, 0xD8]) { jpeg_inks(bytes) } else { tiff_inks(bytes) }
+    }
+}
+
+/// The ink amounts of a four-component JPEG (its samples inverted back; YCCK converted to CMYK
+/// first, as JPEG readers do).
+fn jpeg_inks(bytes: &[u8]) -> Option<Inks> {
+    let mut d = zune_jpeg::JpegDecoder::new_with_options(ZCursor::new(bytes), DecoderOptions::default());
+    d.decode_headers().ok()?;
+    let space = d.input_colorspace()?;
+    if d.info()?.components != 4 || !matches!(space, ColorSpace::CMYK | ColorSpace::YCCK) {
+        return None;
+    }
+    let (w, h) = d.dimensions()?;
+    let (w, h) = (u32::try_from(w).ok()?, u32::try_from(h).ok()?);
+    pixels(w, h)?;
+    d.set_options(DecoderOptions::default().jpeg_set_out_colorspace(space));
+    let mut data = d.decode().ok()?;
+    for p in data.as_chunks_mut::<4>().0 {
+        if space == ColorSpace::YCCK {
+            let [y, cb, cr] = [p[0], p[1], p[2]].map(f32::from);
+            // libjpeg's YCCK → CMYK: the complement of the YCbCr colour's RGB.
+            p[0] = (434.456 - y - 1.402 * cr).clamp(0.0, 255.0) as u8;
+            p[1] = (119.541 - y + 0.344 * cb + 0.714 * cr).clamp(0.0, 255.0) as u8;
+            p[2] = (481.816 - y - 1.772 * cb).clamp(0.0, 255.0) as u8;
+        }
+        for v in p.iter_mut() {
+            *v = 255 - *v;
+        }
+    }
+    Inks::new(w, h, data)
+}
+
+/// The ink amounts of a chunky CMYK TIFF (16-bit samples to 8 bits).
+fn tiff_inks(bytes: &[u8]) -> Option<Inks> {
+    let (kind, mut d) = tiff(bytes)?;
+    let (w, h) = d.dimensions().ok()?;
+    // Planar samples (one plane per ink) would read as interleaved.
+    let planar = d.find_tag_unsigned::<u16>(tiff::tags::Tag::PlanarConfiguration).ok().flatten().is_some_and(|p| p != 1);
+    if !matches!(kind, tiff::ColorType::CMYK(8 | 16)) || planar || pixels(w, h).is_none() {
+        return None;
+    }
+    let data = match d.read_image().ok()? {
+        tiff::decoder::DecodingResult::U8(v) => v,
+        tiff::decoder::DecodingResult::U16(v) => v.iter().map(|s| (s >> 8) as u8).collect(),
+        _ => return None,
+    };
+    Inks::new(w, h, data)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn inks() -> Inks {
+        Inks::new(3, 2, vec![0, 40, 100, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 0, 0, 0, 0, 255, 12, 34, 56, 78]).unwrap()
+    }
+
+    #[test]
+    fn a_cmyk_tiff_keeps_its_ink_amounts_and_shows_as_rgb() {
+        let b = ImageBlob::cmyk_tiff(&inks()).unwrap();
+        assert_eq!(b.mime, "image/tiff");
+        assert!(b.is_cmyk());
+        assert_eq!(b.cmyk(), Some(inks()), "lossless");
+        // Every image reader sees an RGB image: cyan is (0, 255, 255).
+        let rgb = image::load_from_memory(&b.bytes).unwrap().to_rgb8();
+        assert_eq!(rgb.get_pixel(1, 0).0, [0, 255, 255]);
+    }
+
+    #[test]
+    fn a_cmyk_jpeg_reads_back_as_ink_amounts() {
+        // A flat CMYK JPEG: Adobe's inverted samples with its marker.
+        let flat = [10u8, 40, 100, 20];
+        let px: Vec<u8> = (0..16 * 16).flat_map(|_| flat).collect();
+        let mut jpg = Vec::new();
+        jpeg_encoder::Encoder::new(&mut jpg, 100).encode(&px, 16, 16, jpeg_encoder::ColorType::Cmyk).unwrap();
+        let b = ImageBlob::new("image/jpeg", jpg);
+        assert_eq!(jpeg_components(&b.bytes), Some(4));
+        assert!(b.is_cmyk());
+        let back = b.cmyk().unwrap();
+        assert_eq!((back.width, back.height), (16, 16));
+        for p in back.data.as_chunks::<4>().0 {
+            assert!(p.iter().zip(flat).all(|(a, b)| a.abs_diff(b) <= 2), "{p:?}");
+        }
+    }
+
+    #[test]
+    fn other_images_are_not_cmyk() {
+        let mut png = Vec::new();
+        image::RgbaImage::new(2, 2).write_to(&mut Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+        let mut jpg = Vec::new();
+        image::RgbImage::new(8, 8).write_to(&mut Cursor::new(&mut jpg), image::ImageFormat::Jpeg).unwrap();
+        for b in [ImageBlob::png(png), ImageBlob::new("image/jpeg", jpg), ImageBlob::new("image/tiff", b"II*\0junk".to_vec())] {
+            assert!(!b.is_cmyk() && b.cmyk().is_none(), "{}", b.mime);
+        }
+        assert_eq!(Inks::new(2, 2, vec![0; 15]), None, "too few samples");
+        assert_eq!(Inks::new(0, 2, vec![]), None, "empty");
+        assert_eq!(Inks::new(1 << 14, 1 << 13, vec![]), None, "too large");
+    }
+}

crates/doc/src/lib.rs

@@ -9,6 +9,7 @@ pub mod appearance;
 pub mod assets;
 pub mod blend;
 pub mod clipnest;
+pub mod cmyk;
 pub mod graph;
 pub mod hit;
 pub mod inks;
@@ -77,8 +78,8 @@ pub use setup::{Background, DocSetup, ExportText, GridSize, Quotes};
 pub use slices::{CellAlign, CellVAlign, Slice, SliceArea, SliceKind, SliceOptions, SliceSource};
 pub use style_libs::StyleLibrary;
 pub use text::{
-    AreaOptions, CharPosition, CharStyle, FirstBaseline, Justify, Mojikumi, ParaDirection, ParaStyle, PathEffect, ScriptMetrics, TabAlign, TabStop,
-    TextKind, TextObject, TextRun, TextStyleDef, TextWrap, WrapShape,
+    AreaOptions, CharPosition, CharStyle, FirstBaseline, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathEffect, ScriptMetrics,
+    TabAlign, TabStop, TextKind, TextObject, TextRun, TextStyleDef, TextWrap, WrapShape,
 };
 pub use vectorcraft_color as color;
 pub use vectorcraft_geom as geom;

crates/doc/src/node.rs

@@ -1,14 +1,17 @@
 //! Document nodes.
 
+use std::collections::BTreeSet;
 use std::sync::Arc;
 
 use serde::{Deserialize, Serialize};
 use vectorcraft_color::BlendMode;
-use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect, shapes};
+use vectorcraft_geom::shapes::{self, CornerKind};
+use vectorcraft_geom::{Affine, BezPath, FillRule, PathData, Point, Rect};
 
 use crate::appearance::Appearance;
 use crate::live::{BlendSpec, EnvelopeKind, GradientMesh, Outliner};
 use crate::pattern::RepeatSpec;
+use crate::selection::AnchorRef;
 use crate::text::TextObject;
 
 /// Stable per-document object id. Never reused.
@@ -82,6 +85,9 @@ pub enum LiveShape {
         /// Corner radii: top-left, top-right, bottom-right, bottom-left. In the same units as
         /// `w`/`h`: the corners are circular arcs in the document whenever `xf` doesn't scale.
         radii: [f64; 4],
+        /// Corner kinds, in the same order (Live Corners' corner types).
+        #[serde(default, skip_serializing_if = "all_round")]
+        kinds: [CornerKind; 4],
         /// Maps the untransformed shape (origin at its top-left) into the document. A rotation
         /// or reflection plus a move, unless a shear (or a file saved before transforms folded
         /// their scale into `w`/`h`) put more in it.
@@ -118,15 +124,8 @@ impl LiveShape {
     /// Regenerate the path.
     pub fn to_path(&self) -> PathData {
         match self {
-            LiveShape::Rectangle { w, h, radii, xf } => {
-                let r = Rect::new(0.0, 0.0, *w, *h);
-                let p = if radii.iter().all(|x| (x - radii[0]).abs() < 1e-9) {
-                    shapes::rounded_rectangle(r, radii[0])
-                } else {
-                    // Per-corner radii: generate uniformly then adjust (approximation until M2.5).
-                    shapes::rounded_rectangle(r, radii.iter().cloned().fold(0.0, f64::max))
-                };
-                p.transformed(*xf)
+            LiveShape::Rectangle { w, h, radii, kinds, xf } => {
+                shapes::rectangle_with_corners(Rect::new(0.0, 0.0, *w, *h), *radii, *kinds).transformed(*xf)
             }
             LiveShape::Ellipse { w, h, xf, .. } => shapes::ellipse(Rect::new(0.0, 0.0, *w, *h)).transformed(*xf),
             LiveShape::Polygon { radius, sides, xf } => shapes::polygon(Point::ZERO, *radius, *sides, 0.0).transformed(*xf),
@@ -144,7 +143,7 @@ impl LiveShape {
     /// scale in `xf` keep their exact geometry until they're next transformed).
     pub fn transform(&mut self, a: Affine) -> bool {
         match self {
-            LiveShape::Rectangle { w, h, radii, xf } => {
+            LiveShape::Rectangle { w, h, radii, xf, .. } => {
                 let m = a * *xf;
                 let [a0, a1, a2, a3, _, _] = a.as_coeffs();
                 let moves_only = (a0 - 1.0).abs() < 1e-12 && a1.abs() < 1e-12 && a2.abs() < 1e-12 && (a3 - 1.0).abs() < 1e-12;
@@ -185,6 +184,44 @@ impl LiveShape {
             _ => false,
         }
     }
+    /// The corner (radii order) of each anchor of a rectangle's path; empty for other shapes.
+    pub fn anchor_corners(&self) -> Vec<usize> {
+        match self {
+            LiveShape::Rectangle { w, h, radii, .. } => shapes::rectangle_anchor_corners(Rect::new(0.0, 0.0, *w, *h), *radii),
+            _ => vec![],
+        }
+    }
+    /// The corners of a rectangle that hold one of `anchors` (of its only subpath).
+    pub fn corners_of(&self, anchors: &BTreeSet<AnchorRef>) -> [bool; 4] {
+        let map = self.anchor_corners();
+        let mut out = [false; 4];
+        for k in anchors.iter().filter(|(si, _)| *si == 0).filter_map(|(_, ai)| map.get(*ai)) {
+            if let Some(c) = out.get_mut(*k) {
+                *c = true;
+            }
+        }
+        out
+    }
+    /// The corners Live Corners edit for a selection: those holding a selected anchor when the
+    /// shape is partly selected (Direct Selection), else all four.
+    pub fn picked_corners(&self, partial: Option<&BTreeSet<AnchorRef>>) -> [bool; 4] {
+        let picked = partial.map_or([true; 4], |a| self.corners_of(a));
+        if picked.contains(&true) { picked } else { [true; 4] }
+    }
+    /// The anchors of a rectangle's `corners` (to keep them selected as its path changes).
+    pub fn corner_anchors(&self, corners: [bool; 4]) -> BTreeSet<AnchorRef> {
+        self.anchor_corners().into_iter().enumerate().filter(|(_, k)| corners.get(*k) == Some(&true)).map(|(ai, _)| (0, ai)).collect()
+    }
+    /// The radius and kind the `corners` of a rectangle share (each `None` when they differ).
+    pub fn corner_style(&self, corners: [bool; 4]) -> (Option<f64>, Option<CornerKind>) {
+        let LiveShape::Rectangle { radii, kinds, .. } = self else { return (None, None) };
+        fn shared<T: Copy>(v: [T; 4], corners: [bool; 4], same: impl Fn(T, T) -> bool) -> Option<T> {
+            let mut it = v.into_iter().zip(corners).filter(|(_, on)| *on).map(|(x, _)| x);
+            let first = it.next()?;
+            it.all(|x| same(x, first)).then_some(first)
+        }
+        (shared(*radii, corners, |a, b| (a - b).abs() < 1e-9), shared(*kinds, corners, |a, b| a == b))
+    }
     /// Rotation angle of the live shape in degrees (shown in the Properties panel).
     pub fn angle_deg(&self) -> f64 {
         match self {
@@ -197,6 +234,10 @@ impl LiveShape {
     }
 }
 
+fn all_round(kinds: &[CornerKind; 4]) -> bool {
+    kinds.iter().all(|k| *k == CornerKind::Round)
+}
+
 /// What a transform scales besides geometry, by its mean scale (the square root of its
 /// determinant). `Scaling::default()` (and `false`) scales nothing else; `true` scales stroke
 /// weights and dashes only. Transforms the user asks for take theirs from Scale Strokes & Effects
@@ -1200,14 +1241,44 @@ mod tests {
 
     #[test]
     fn rect_live_shape_roundtrip() {
-        let l = LiveShape::Rectangle { w: 10.0, h: 20.0, radii: [0.0; 4], xf: Affine::translate((5.0, 5.0)) };
+        let l = LiveShape::Rectangle { w: 10.0, h: 20.0, radii: [0.0; 4], kinds: Default::default(), xf: Affine::translate((5.0, 5.0)) };
         assert_eq!(l.to_path().bounds(), Some(Rect::new(5.0, 5.0, 15.0, 25.0)));
         assert_eq!(l.label(), "Rectangle");
     }
 
+    #[test]
+    fn rectangle_corners_map_to_their_anchors() {
+        let mut l = LiveShape::Rectangle { w: 100.0, h: 50.0, radii: [0.0, 10.0, 0.0, 0.0], kinds: Default::default(), xf: Affine::IDENTITY };
+        // Anchors: top-left, the top-right corner's two, bottom-right, bottom-left.
+        assert_eq!(l.anchor_corners(), [0, 1, 1, 2, 3]);
+        assert_eq!(l.to_path().anchor_count(), 5);
+        let set = |v: &[usize]| v.iter().map(|ai| (0, *ai)).collect::<BTreeSet<AnchorRef>>();
+        assert_eq!(l.corners_of(&set(&[2, 4])), [false, true, false, true]);
+        assert_eq!(l.corners_of(&set(&[9])), [false; 4], "out of range");
+        assert_eq!(l.corner_anchors([false, true, false, true]), set(&[1, 2, 4]));
+        // Partly selected: the corners of the selected anchors; wholly (or no anchor): all four.
+        assert_eq!(l.picked_corners(Some(&set(&[0]))), [true, false, false, false]);
+        assert_eq!(l.picked_corners(None), [true; 4]);
+        assert_eq!(l.picked_corners(Some(&set(&[]))), [true; 4]);
+        assert_eq!(l.corner_style([false, true, false, false]), (Some(10.0), Some(CornerKind::Round)));
+        assert_eq!(l.corner_style([true, true, false, false]), (None, Some(CornerKind::Round)));
+        assert_eq!(l.corner_style([true, false, true, true]), (Some(0.0), Some(CornerKind::Round)));
+        // Corner kinds save only when some corner isn't round, and older files read as round.
+        let json = serde_json::to_value(&l).unwrap();
+        assert!(json.get("kinds").is_none(), "{json}");
+        assert_eq!(serde_json::from_value::<LiveShape>(json).unwrap(), l);
+        if let LiveShape::Rectangle { kinds, .. } = &mut l {
+            kinds[1] = CornerKind::Chamfer;
+        }
+        let json = serde_json::to_value(&l).unwrap();
+        assert_eq!(json["kinds"], serde_json::json!(["round", "chamfer", "round", "round"]));
+        assert_eq!(serde_json::from_value::<LiveShape>(json).unwrap(), l);
+        assert!(LiveShape::Ellipse { w: 1.0, h: 1.0, pie: (0.0, 360.0), xf: Affine::IDENTITY }.anchor_corners().is_empty());
+    }
+
     /// A node holding a live rectangle (`w` × `h`, all radii `r`, placed by `xf`) and its path.
     fn live_rect(w: f64, h: f64, r: f64, xf: Affine) -> Node {
-        let live = LiveShape::Rectangle { w, h, radii: [r; 4], xf };
+        let live = LiveShape::Rectangle { w, h, radii: [r; 4], kinds: Default::default(), xf };
         let mut n = Node::path(NodeId(1), live.to_path(), Appearance::default_art());
         if let NodeKind::Path { live: slot, .. } = &mut n.kind {
             *slot = Some(live);
@@ -1216,7 +1287,7 @@ mod tests {
     }
 
     fn live_of(n: &Node) -> (f64, f64, [f64; 4], Affine) {
-        let NodeKind::Path { live: Some(LiveShape::Rectangle { w, h, radii, xf }), .. } = &n.kind else { panic!("not a live rectangle") };
+        let NodeKind::Path { live: Some(LiveShape::Rectangle { w, h, radii, xf, .. }), .. } = &n.kind else { panic!("not a live rectangle") };
         (*w, *h, *radii, *xf)
     }
 

crates/doc/src/text.rs

@@ -293,6 +293,9 @@ pub struct ParaStyle {
     /// bidirectional text (UAX #9). None: from each paragraph's first strong character (Hebrew or
     /// Arabic: right to left).
     pub direction: Option<ParaDirection>,
+    /// How leading is measured (Paragraph panel menu): from baseline to baseline, or from the top
+    /// of one line's ideographic em box to the next.
+    pub leading_model: LeadingModel,
 }
 
 /// [`ParaStyle`] as saved. [`Justify::Auto`] is written as the alignment it has in the paragraph
@@ -324,6 +327,8 @@ struct ParaStyleFile {
     mojikumi: Mojikumi,
     #[serde(default, skip_serializing_if = "Option::is_none")]
     direction: Option<ParaDirection>,
+    #[serde(default, skip_serializing_if = "crate::skip::is_default")]
+    leading_model: LeadingModel,
 }
 
 impl From<ParaStyle> for ParaStyleFile {
@@ -345,6 +350,7 @@ impl From<ParaStyle> for ParaStyleFile {
             style_name,
             mojikumi,
             direction,
+            leading_model,
             ..
         } = p;
         Self {
@@ -360,6 +366,7 @@ impl From<ParaStyle> for ParaStyleFile {
             style_name,
             mojikumi,
             direction,
+            leading_model,
         }
     }
 }
@@ -378,9 +385,23 @@ impl From<ParaStyleFile> for ParaStyle {
             style_name,
             mojikumi,
             direction,
+            leading_model,
             ..
         } = f;
-        Self { justify, left_indent, right_indent, first_line_indent, space_before, space_after, hyphenate, tabs, style_name, mojikumi, direction }
+        Self {
+            justify,
+            left_indent,
+            right_indent,
+            first_line_indent,
+            space_before,
+            space_after,
+            hyphenate,
+            tabs,
+            style_name,
+            mojikumi,
+            direction,
+            leading_model,
+        }
     }
 }
 
@@ -392,6 +413,20 @@ pub enum ParaDirection {
     RightToLeft,
 }
 
+/// How a paragraph's leading is measured.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum LeadingModel {
+    /// From one line's baseline to the next's: a line's leading is the space above it, and area
+    /// type's first baseline follows Area Type Options › First Baseline.
+    #[default]
+    RomanBaseline,
+    /// From the top of one line's ideographic em box (the right side, in vertical type) to the
+    /// next's: a line's leading is the space below it, and area type's first line touches the top
+    /// of the frame. Japanese layout's usual model.
+    EmBoxTop,
+}
+
 /// How Japanese punctuation is spaced (JLREQ 3.1). Full-width punctuation is half a glyph and half
 /// a space: an opening bracket's space before it, a closing bracket's, a comma's or a full stop's
 /// after it.

crates/engine/src/cmd/buildcmds.rs

@@ -16,10 +16,11 @@ use serde_json::{Value, json};
 use vectorcraft_color::{Color, Paint};
 use vectorcraft_doc::appearance::{AppearanceItem, FillLayer, StrokeLayer};
 use vectorcraft_doc::{Appearance, Document, Node, NodeId, NodeKind, Selection};
-use vectorcraft_geom::{FillRule, Point, Rect, Shape as _};
+use vectorcraft_geom::{FillRule, PathData, Point, Rect};
 use vectorcraft_pathops as po;
 use vectorcraft_tools::builder::{
-    self as b, EDGE_NAME, FACE_NAME, LIVE_PAINT_NAME, SOURCES_NAME, edge_near, face_at, is_live_paint, sample_polyline, shapes_for, sorted_roots,
+    self as b, BuilderMap, EDGE_NAME, FACE_NAME, LIVE_PAINT_NAME, SOURCES_NAME, Touched, edge_near, face_at, is_live_paint, sample_polyline,
+    sorted_roots,
 };
 use vectorcraft_trace as tr;
 
@@ -38,7 +39,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Shape Builder",
             [],
             None,
-            "{ids?: [id…] (default: selection), points: [[x,y]…] (drag path; one point = click), erase?: bool (Alt-drag deletes the regions), fill?: \"#rrggbb\" | {color|swatch|gradient|none} (default: the fill of the object under the first point)} → {ids, merged, regions}",
+            "{ids?: [id…] (default: selection), points: [[x,y]…] (drag path; one point = click), erase?: bool (Alt-drag deletes the regions, and the pieces of unfilled open paths within tolerance), tolerance?: pt (2, erase only), fill?: \"#rrggbb\" | {color|swatch|gradient|none} (default: the fill of the object under the first point; the current fill for an area only lines enclose)} → {ids, merged, regions, lines}",
             has_selection_or_ids,
             sb_merge
         ),
@@ -47,7 +48,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Shape Builder Regions",
             [],
             None,
-            "{ids?} → {regions: [{bounds: [x0,y0,x1,y1], area, sources: [id…]}]} faces of the planar arrangement",
+            "{ids?} → {regions: [{bounds: [x0,y0,x1,y1], area, sources: [id…]}], lines: [{bounds, source: id}]} faces of the planar arrangement (unfilled open paths cut them; sources is empty for an area only they enclose) and the pieces of those open paths",
             has_selection_or_ids,
             sb_regions
         ),
@@ -224,37 +225,51 @@ fn sb_merge(s: &mut Session, p: &Value) -> Result<Value> {
         return Err(bad(C, "points must be a non-empty list of finite [x,y]"));
     }
     let erase = bool_or(p, "erase", false);
+    // Line pieces are only deleted (Alt), never merged.
+    let line_tol = erase.then(|| f64_or(p, "tolerance", 2.0).clamp(0.0, 1000.0));
     let fill = fill_param(s, p, C)?;
+    let current_fill = s.paint.fill.clone();
     let roots = root_ids(s, p)?;
     let label = if erase { "Shape Builder Delete" } else { "Shape Builder" };
-    let (ids, merged, count) = s.edit(label, |d, sel| {
-        let (shapes, leaves) = shapes_for(d, &roots);
+    let (ids, merged, regions, lines) = s.edit(label, |d, sel| {
+        let (map, leaves) = BuilderMap::new(d, &roots);
         let leaves: Vec<Node> = leaves.into_iter().cloned().collect();
-        if shapes.is_empty() {
+        if map.shapes.is_empty() {
             return Err(EngineError::Other("Shape Builder: select paths or compound paths".into()));
         }
-        let regs = po::regions(&shapes);
-        let shapes_r: Vec<(kurbo::BezPath, Rect)> = regs.iter().map(|r| (r.path.to_bezpath(), r.path.bounds().unwrap_or(Rect::ZERO))).collect();
         let step = (d.bounds_of(&roots, false).map(|r| r.width().max(r.height())).unwrap_or(100.0) / 2000.0).max(0.25);
-        let mut touched: Vec<usize> = vec![];
+        let mut touched = Touched::default();
         for q in sample_polyline(&pts, step) {
-            if let Some(i) = shapes_r.iter().position(|(bp, bb)| bb.contains(q) && bp.winding(q) != 0)
-                && !touched.contains(&i)
-            {
-                touched.push(i);
-            }
+            touched.add(map.hit(q, line_tol));
         }
         if touched.is_empty() {
             return Err(EngineError::Other("Shape Builder: no region under the pointer".into()));
         }
-        let picked: Vec<&po::Region> = touched.iter().map(|&i| &regs[i]).collect();
-        let union = po::merge_regions(&picked);
-        let affected: Vec<bool> = (0..shapes.len()).map(|i| picked.iter().any(|r| r.sources.contains(&i))).collect();
-        let style_src = regs[touched[0]].top();
+        let picked: Vec<&po::Region> = touched.regions.iter().filter_map(|&i| map.regions.get(i).map(|r| &r.0)).collect();
+        let union = if picked.is_empty() { PathData::default() } else { po::merge_regions(&picked) };
+        // The merged shape takes the look of the front-most object over the first region, or (for an
+        // area only lines enclose) of the front-most object and the current fill.
+        let covered = picked.iter().find_map(|r| r.top());
+        let style_src = covered.or(map.shapes.len().checked_sub(1));
+        let merged_fill = fill.or_else(|| covered.is_none().then_some(current_fill));
         let mut new_nodes: Vec<Node> = vec![];
         let mut merged_id = None;
-        for (i, (sh, leaf)) in shapes.iter().zip(&leaves).enumerate() {
-            if !affected[i] {
+        for (i, (sh, leaf)) in map.shapes.iter().zip(&leaves).enumerate() {
+            let pieces: Vec<usize> = map.lines.iter().enumerate().filter(|(_, (l, _))| l.key == i as u64).map(|(k, _)| k).collect();
+            if !pieces.is_empty() {
+                // An open path loses the pieces deleted and those between merged (or deleted) regions.
+                let keep: Vec<usize> =
+                    pieces.iter().copied().filter(|k| !touched.lines.contains(k) && !map.line_between(*k, &touched.regions)).collect();
+                if keep.len() == pieces.len() {
+                    new_nodes.push(d.reid(leaf));
+                } else {
+                    for k in keep {
+                        if let Some((l, _)) = map.lines.get(k) {
+                            new_nodes.push(shape_node(d, l.path.clone(), Some(leaf)));
+                        }
+                    }
+                }
+            } else if !picked.iter().any(|r| r.sources.contains(&i)) {
                 new_nodes.push(d.reid(leaf));
             } else {
                 let rest = po::boolean(&sh.path, sh.rule, &union, FillRule::NonZero, po::BoolOp::Difference);
@@ -262,9 +277,9 @@ fn sb_merge(s: &mut Session, p: &Value) -> Result<Value> {
                     new_nodes.push(shape_node(d, rest, Some(leaf)));
                 }
             }
-            if !erase && Some(i) == style_src {
+            if !erase && !union.is_empty() && Some(i) == style_src {
                 let mut m = shape_node(d, union.clone(), Some(leaf));
-                if let Some(f) = &fill {
+                if let Some(f) = &merged_fill {
                     m.appearance.set_fill(f.clone());
                 }
                 merged_id = Some(m.id);
@@ -273,9 +288,9 @@ fn sb_merge(s: &mut Session, p: &Value) -> Result<Value> {
         }
         let new_ids = replace_roots(d, &roots, new_nodes)?;
         sel.set(new_ids.iter().copied());
-        Ok((new_ids, merged_id, touched.len()))
+        Ok((new_ids, merged_id, touched.regions.len(), touched.lines.len()))
     })?;
-    Ok(json!({ "ids": ids_json(&ids), "merged": merged.map(|m| m.0), "regions": count }))
+    Ok(json!({ "ids": ids_json(&ids), "merged": merged.map(|m| m.0), "regions": regions, "lines": lines }))
 }
 
 /// Remove the roots and insert `nodes` where the front-most root was. Returns the new ids.
@@ -300,20 +315,22 @@ fn replace_roots(d: &mut Document, roots: &[NodeId], nodes: Vec<Node>) -> Result
 fn sb_regions(s: &mut Session, p: &Value) -> Result<Value> {
     let roots = root_ids(s, p)?;
     let d = &s.doc()?.doc;
-    let (shapes, leaves) = shapes_for(d, &roots);
-    let regs = po::regions(&shapes);
-    let out: Vec<Value> = regs
+    let (map, leaves) = BuilderMap::new(d, &roots);
+    let id_of = |i: usize| leaves.get(i).map(|n| n.id.0);
+    let regions: Vec<Value> = map
+        .regions
         .iter()
-        .filter_map(|r| {
-            let bb = r.path.bounds()?;
-            Some(json!({
+        .map(|(r, _, bb)| {
+            json!({
                 "bounds": [bb.x0, bb.y0, bb.x1, bb.y1],
                 "area": po::area(&r.path, FillRule::NonZero),
-                "sources": r.sources.iter().map(|&i| leaves[i].id.0).collect::<Vec<_>>(),
-            }))
+                "sources": r.sources.iter().filter_map(|&i| id_of(i)).collect::<Vec<_>>(),
+            })
         })
         .collect();
-    Ok(json!({ "regions": out }))
+    let lines: Vec<Value> =
+        map.lines.iter().map(|(l, bb)| json!({ "bounds": [bb.x0, bb.y0, bb.x1, bb.y1], "source": id_of(l.key as usize) })).collect();
+    Ok(json!({ "regions": regions, "lines": lines }))
 }
 
 // ---------- Live Paint ----------

crates/engine/src/cmd/create.rs

@@ -166,7 +166,13 @@ fn rect_of(p: &Value, cmd: &str) -> Result<Rect> {
 fn rectangle(s: &mut Session, p: &Value) -> Result<Value> {
     let r = rect_of(p, "shape.rectangle")?;
     let radius = f64_or(p, "radius", 0.0).max(0.0);
-    let live = LiveShape::Rectangle { w: r.width(), h: r.height(), radii: [radius; 4], xf: Affine::translate(r.origin().to_vec2()) };
+    let live = LiveShape::Rectangle {
+        w: r.width(),
+        h: r.height(),
+        radii: [radius; 4],
+        kinds: Default::default(),
+        xf: Affine::translate(r.origin().to_vec2()),
+    };
     let label = if radius > 0.0 { "Rounded Rectangle" } else { "Rectangle" };
     add_art(s, label, path_kind(live.to_path(), Some(live)), None)
 }

crates/engine/src/cmd/fileio/encode.rs

@@ -355,7 +355,8 @@ pub fn encode(doc: &Document, format: &str, p: &Value) -> Result<Vec<u8>> {
 }
 
 /// Like [`encode`], also returning the encoder's warnings (PDF and SVG: options not applied yet,
-/// features approximated or left out; the other formats have none).
+/// features approximated or left out; every format that draws type: fonts written in the fallback
+/// font).
 pub fn encode_with_warnings(doc: &Document, format: &str, p: &Value) -> Result<(Vec<u8>, Vec<String>)> {
     let f = super::writable(C, Some(format), None)?;
     encode_all(doc, f.id, p)?.single(f)
@@ -364,6 +365,19 @@ pub fn encode_with_warnings(doc: &Document, format: &str, p: &Value) -> Result<(
 /// [`encode`], with every file the export writes.
 pub fn encode_all(doc: &Document, format: &str, p: &Value) -> Result<Encoded> {
     let f = super::writable(C, Some(format), None)?;
+    let mut enc = encode_files(doc, f, p)?;
+    // Formats that draw type: missing fonts come out in the fallback font (PDF and SVG say so
+    // themselves: SVG only when it outlines or embeds fonts).
+    if (f.raster || matches!(f.id, "eps" | "emf" | "wmf"))
+        && let Some(w) = crate::cmd::fonts::substitution_warning(doc)
+    {
+        enc.warnings.push(w);
+    }
+    Ok(enc)
+}
+
+/// [`encode_all`] without the font substitution warning.
+fn encode_files(doc: &Document, f: &Format, p: &Value) -> Result<Encoded> {
     let doc = &*doc.without_edit_modes();
     let n = doc.artboards.len();
     // SVG reads its own `useArtboards` (an SVG option).
@@ -374,7 +388,7 @@ pub fn encode_all(doc: &Document, format: &str, p: &Value) -> Result<Encoded> {
         if let Some(o) = q.as_object_mut() {
             o.remove("useArtboards");
         }
-        return encode_all(&single_artboard(doc, bounds, "Art"), f.id, &q);
+        return encode_files(&single_artboard(doc, bounds, "Art"), f, &q);
     }
     let bytes = match f.id {
         "vectorcraft" => super::native::encode(C, f, doc, p)?,

crates/engine/src/cmd/fileio/load.rs

@@ -282,13 +282,15 @@ pub(super) fn new_from_template(s: &mut Session, p: &Value) -> Result<Value> {
     open_template(s, src.name, &src.bytes, src.path)
 }
 
-/// Decode an image's header (and, for formats stored as PNG, its pixels).
+/// Decode an image's header (and, for formats stored as PNG, its pixels). CMYK TIFFs are kept as
+/// they are, with their ink amounts ([`ImageBlob::cmyk`]).
 pub fn raster_image(bytes: &[u8]) -> Result<RasterImage> {
     let reader = image::ImageReader::new(Cursor::new(bytes)).with_guessed_format().map_err(err)?;
     let kind = reader.format().ok_or_else(|| err("not an image VectorCraft reads (see document.formats)"))?;
     let f = image_format(kind).ok_or_else(|| err(format!("{kind:?} images can't be opened (see document.formats)")))?;
     let ppi = super::ppi::resolution(bytes);
-    let (bytes, mime, (width, height)) = if matches!(f.id, "png" | "jpg" | "gif" | "webp") {
+    let cmyk = || ImageBlob::new(f.mime, bytes.to_vec()).cmyk().is_some();
+    let (bytes, mime, (width, height)) = if matches!(f.id, "png" | "jpg" | "gif" | "webp") || (f.id == "tiff" && cmyk()) {
         (bytes.to_vec(), f.mime, reader.into_dimensions().map_err(err)?)
     } else {
         let img = reader.decode().map_err(err)?.to_rgba8();

crates/engine/src/cmd/fileio/pdf.rs

@@ -276,6 +276,7 @@ pub(super) fn encode_carrying(cmd: &str, doc: &Document, p: &Value, native: impl
     }
     let r = super::super::rasterfx::export_pdf_with_report(flat.as_ref().unwrap_or(doc), &opts).map_err(|e| pdf_error(cmd, e))?;
     warnings.extend(r.warnings);
+    warnings.extend(crate::cmd::fonts::substitution_warning(doc));
     Ok((r.bytes, warnings))
 }
 

crates/engine/src/cmd/fileio/svg.rs

@@ -166,5 +166,11 @@ pub(super) fn encode(doc: &Document, p: &Value, compressed: bool) -> Result<Enco
         }
         enc.files.push((artboard, if compressed { vectorcraft_svg::compress_bytes(&bytes) } else { bytes }));
     }
+    // Live type names its fonts; outlines and embedded fonts are the fallback font's.
+    if (opts.outline_text || opts.embed_fonts)
+        && let Some(w) = crate::cmd::fonts::substitution_warning(doc)
+    {
+        enc.warnings.push(w);
+    }
     Ok(enc)
 }

crates/engine/src/cmd/fileio/tests.rs

@@ -103,6 +103,17 @@ fn webp_opens_at_its_pixel_size() {
     assert_eq!((r.width, r.height, r.blob.mime.as_str()), (3, 2, "image/webp"));
 }
 
+#[test]
+fn cmyk_tiffs_keep_their_inks_and_other_tiffs_become_png() {
+    let inks = vectorcraft_doc::cmyk::Inks::new(2, 1, vec![0, 102, 255, 0, 10, 20, 30, 40]).unwrap();
+    let tiff = vectorcraft_doc::ImageBlob::cmyk_tiff(&inks).unwrap();
+    let r = raster_image(&tiff.bytes).unwrap();
+    assert_eq!((r.width, r.height, r.blob.mime.as_str()), (2, 1, "image/tiff"));
+    assert_eq!(r.blob.cmyk(), Some(inks));
+    let rgb = raster_image(&image_bytes(2, 1, image::ImageFormat::Tiff)).unwrap();
+    assert_eq!(rgb.blob.mime, "image/png");
+}
+
 #[test]
 fn content_beats_a_wrong_extension() {
     let png = image_bytes(2, 2, image::ImageFormat::Png);

crates/engine/src/cmd/fileio/tests_pdffidelity.rs

@@ -67,3 +67,40 @@ fn load_options_read_text_and_layers() {
     let d = LoadOptions::default();
     assert_eq!((d.text_as, d.layers, d.is_partial()), (TextAs::Text, true, false));
 }
+
+#[test]
+fn exports_that_draw_type_in_a_missing_font_say_it_is_the_fallback_font() {
+    let page = PdfPage {
+        resources: "/Font << /F1 << /Type /Font /Subtype /Type1 /BaseFont /Zyxwvu-Serif >> >>".into(),
+        ..PdfPage::new(200.0, 100.0, "BT /F1 12 Tf 10 50 Td (Hello) Tj ET")
+    };
+    let mut s = Session::new();
+    let r = open(&mut s, &pdf(&[page], None), json!({})).unwrap();
+    let fonts = s.execute("text.fonts", &json!({})).unwrap();
+    let family = fonts[0]["family"].as_str().unwrap().to_string();
+    assert_eq!(fonts[0]["status"], "missing", "{fonts}");
+    assert!(r["warnings"].to_string().contains(&family), "opening lists it: {r}");
+    let warned = |s: &mut Session, p: Value| {
+        let w = s.execute("document.serialize", &p).unwrap()["warnings"].to_string();
+        w.contains(&family) && w.contains(vectorcraft_text::FALLBACK_FAMILY)
+    };
+    for p in [
+        json!({"format": "pdf"}),
+        json!({"format": "pdf", "advanced": {"outlineText": false}}),
+        json!({"format": "png"}),
+        json!({"format": "eps"}),
+        json!({"format": "emf"}),
+        json!({"format": "svg", "outlineText": true}),
+        json!({"format": "svg", "embedFonts": true}),
+    ] {
+        assert!(warned(&mut s, p.clone()), "{p}");
+    }
+    // Live SVG type and the native file name the font itself.
+    for p in [json!({"format": "svg", "outlineText": false}), json!({"format": "vectorcraft"}), json!({"format": "txt"})] {
+        assert!(!warned(&mut s, p.clone()), "{p}");
+    }
+    let pdf_export = s.execute("document.exportPdf", &json!({})).unwrap();
+    assert!(pdf_export["warnings"].to_string().contains(&family), "{pdf_export}");
+    s.execute("text.replaceFont", &json!({"from": {"family": family}, "to": {"family": "Source Serif 4"}})).unwrap();
+    assert!(!warned(&mut s, json!({"format": "pdf"})), "replaced: nothing is substituted");
+}

crates/engine/src/cmd/fonts.rs

@@ -2,10 +2,10 @@
 //! another everywhere or in the selection, and selecting the text that uses a font. Also the fonts
 //! available (the bundled and installed ones) and rescanning the installed fonts.
 
-use std::collections::BTreeMap;
+use std::collections::{BTreeMap, BTreeSet};
 
 use serde_json::{Value, json};
-use vectorcraft_doc::{Document, NodeId, NodeKind};
+use vectorcraft_doc::{Document, Node, NodeId, NodeKind};
 
 use super::typecmd::refresh_bounds;
 use super::*;
@@ -85,6 +85,41 @@ fn scope(s: &Session, selection_only: bool) -> Result<Vec<NodeId>> {
     Ok(v)
 }
 
+/// The fonts (family, style) of the type in the layers and symbols of `d`.
+pub(super) fn used_fonts(d: &Document) -> BTreeSet<(String, String)> {
+    let mut fonts = BTreeSet::new();
+    let mut add = |n: &Node| {
+        if let NodeKind::Text(t) = &n.kind {
+            fonts.extend(t.runs.iter().map(|r| (r.style.font_family.clone(), r.style.font_style.clone())));
+        }
+    };
+    d.walk(&mut add);
+    for s in &d.symbols {
+        s.art.walk(&mut add);
+    }
+    fonts
+}
+
+/// What an export that draws type (as outlines, embedded fonts or pixels) says when `d` uses font
+/// families that aren't available: their type is drawn in the fallback font, not the font it names.
+pub(super) fn substitution_warning(d: &Document) -> Option<String> {
+    let db = vectorcraft_text::FontDb::global();
+    let mut missing: Vec<String> = used_fonts(d)
+        .into_iter()
+        .filter(|(family, style)| db.resolve(family, style).is_none_or(|(_, m)| m == vectorcraft_text::FontMatch::Missing))
+        .map(|(family, _)| family)
+        .collect();
+    // Sorted by family: its styles are neighbours.
+    missing.dedup();
+    (!missing.is_empty()).then(|| {
+        format!(
+            "fonts that aren't available were written in the fallback font, {}: {} (install them, or replace them with Find Font)",
+            vectorcraft_text::FALLBACK_FAMILY,
+            missing.join(", ")
+        )
+    })
+}
+
 fn text(d: &Document, id: NodeId) -> Option<&vectorcraft_doc::TextObject> {
     match d.node(id).map(|n| &n.kind) {
         Some(NodeKind::Text(t)) => Some(t),

crates/engine/src/cmd/menucmds.rs

@@ -658,7 +658,7 @@ pub(crate) fn detect_shape(path: &PathData) -> Option<LiveShape> {
         }
         let rot = Affine::rotate(e0.y.atan2(e0.x));
         let flip = if e0.cross(e1) < 0.0 { Affine::scale_non_uniform(1.0, -1.0) } else { Affine::IDENTITY };
-        return Some(LiveShape::Rectangle { w, h, radii: [0.0; 4], xf: Affine::translate(a[0].p.to_vec2()) * rot * flip });
+        return Some(LiveShape::Rectangle { w, h, radii: [0.0; 4], kinds: Default::default(), xf: Affine::translate(a[0].p.to_vec2()) * rot * flip });
     }
     let b = path.bounds()?;
     let c = b.center();

crates/engine/src/cmd/object.rs

@@ -6,6 +6,7 @@ use std::sync::Arc;
 use serde_json::{Value, json};
 use vectorcraft_color::{BlendMode, Paint};
 use vectorcraft_doc::{Appearance, Document, Knockout, Node, NodeId, NodeKind, OrientedBox, Scaling};
+use vectorcraft_geom::shapes::CornerKind;
 use vectorcraft_geom::{Affine, FillRule, Point, Rect, Vec2};
 
 use super::edit::{duplicate_in, selected_roots};
@@ -180,7 +181,15 @@ pub fn specs() -> Vec<CommandSpec> {
             set_bounds
         ),
         cmd!("object.expandShape", "Expand Shape", ["Object", "Shape"], None, "{} convert live shapes to plain paths", has_selection, expand_shape),
-        cmd!("object.setLiveShape", "Live Shape Properties", [], None, "{id?, radius?: pt (all corners), sides?: n}", has_selection, set_live_shape),
+        cmd!(
+            "object.setLiveShape",
+            "Live Shape Properties",
+            [],
+            None,
+            "{id?, ids?, radius?: pt, kind?: \"round\"|\"invertedRound\"|\"chamfer\", corners?: [0..3…], sides?: n} (Live Corners: radius and kind set a rectangle's corners: `corners` (0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left), else the corners with a Direct-Selected anchor, else all four; sides: a polygon's)",
+            has_selection,
+            set_live_shape
+        ),
     ]
 }
 
@@ -962,15 +971,50 @@ fn expand_shape(s: &mut Session, _: &Value) -> Result<Value> {
     ok()
 }
 
+/// The `corners` of `object.setLiveShape`: a mask of corner indices 0–3.
+fn corners_param(p: &Value) -> Result<Option<[bool; 4]>> {
+    let Some(v) = p.get("corners").filter(|v| !v.is_null()) else { return Ok(None) };
+    let err = || {
+        bad(
+            "object.setLiveShape",
+            format!("`corners` must list corner indices 0–3 (0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left), not {v}"),
+        )
+    };
+    let mut mask = [false; 4];
+    for k in v.as_array().ok_or_else(err)? {
+        let slot = k.as_u64().and_then(|k| mask.get_mut(usize::try_from(k).ok()?)).ok_or_else(err)?;
+        *slot = true;
+    }
+    Ok(Some(mask))
+}
+
 fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
     let ids = targets(s, p)?;
-    s.edit("Live Shape", |d, _| {
+    let corners = corners_param(p)?;
+    let kind = p
+        .get("kind")
+        .filter(|v| !v.is_null())
+        .map(|v| {
+            serde_json::from_value::<CornerKind>(v.clone())
+                .map_err(|_| bad("object.setLiveShape", format!("`kind` must be \"round\", \"invertedRound\" or \"chamfer\", not {v}")))
+        })
+        .transpose()?;
+    let radius = p.get("radius").and_then(Value::as_f64);
+    s.edit("Live Shape", |d, sel| {
         for id in &ids {
             let Some(NodeKind::Path { path, live: Some(live), .. }) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
+            let partial = sel.anchors.get_mut(id);
+            let picked = corners.unwrap_or_else(|| live.picked_corners(partial.as_deref()));
+            let (layout, selected) = (live.anchor_corners(), partial.as_deref().map(|a| live.corners_of(a)));
             match live {
-                vectorcraft_doc::LiveShape::Rectangle { radii, .. } => {
-                    if let Some(r) = p.get("radius").and_then(Value::as_f64) {
-                        *radii = [r.max(0.0); 4];
+                vectorcraft_doc::LiveShape::Rectangle { radii, kinds, .. } => {
+                    for ((_, r), k) in picked.iter().zip(radii.iter_mut()).zip(kinds.iter_mut()).filter(|((on, _), _)| **on) {
+                        if let Some(radius) = radius {
+                            *r = radius.max(0.0);
+                        }
+                        if let Some(kind) = kind {
+                            *k = kind;
+                        }
                     }
                 }
                 vectorcraft_doc::LiveShape::Polygon { sides, .. } => {
@@ -981,6 +1025,12 @@ fn set_live_shape(s: &mut Session, p: &Value) -> Result<Value> {
                 _ => {}
             }
             *path = live.to_path();
+            // Direct-Selected corners stay selected as they gain or lose anchors.
+            if let (Some(anchors), Some(selected)) = (partial, selected)
+                && live.anchor_corners() != layout
+            {
+                *anchors = live.corner_anchors(selected);
+            }
         }
         Ok(())
     })?;

crates/engine/src/cmd/package.rs

@@ -4,12 +4,11 @@
 //! report). The packaged document links to the copies (Relink); the open document doesn't change.
 //! Without a folder (the web, agents) the same files come back as a zip archive.
 
-use std::collections::{BTreeMap, BTreeSet, HashSet};
+use std::collections::{BTreeMap, HashSet};
 use std::io::Write;
 use std::path::Path;
 
 use serde_json::{Value, json};
-use vectorcraft_doc::{Document, Node, NodeKind};
 
 use super::fileio::{create_dir, write_file};
 use super::*;
@@ -51,21 +50,6 @@ fn font_ext(bytes: &[u8]) -> &'static str {
     }
 }
 
-/// The fonts (family, style) of the type in the layers and symbols of `d`.
-fn used_fonts(d: &Document) -> BTreeSet<(String, String)> {
-    let mut fonts = BTreeSet::new();
-    let mut add = |n: &Node| {
-        if let NodeKind::Text(t) = &n.kind {
-            fonts.extend(t.runs.iter().map(|r| (r.style.font_family.clone(), r.style.font_style.clone())));
-        }
-    };
-    d.walk(&mut add);
-    for s in &d.symbols {
-        s.art.walk(&mut add);
-    }
-    fonts
-}
-
 /// The options of a package.
 struct Options {
     copy_links: bool,
@@ -123,7 +107,7 @@ fn package(s: &mut Session, p: &Value) -> Result<Value> {
         let db = vectorcraft_text::FontDb::global();
         let mut files = HashSet::new();
         lines.push("FONTS".to_string());
-        for (family, style) in used_fonts(&st.doc) {
+        for (family, style) in super::fonts::used_fonts(&st.doc) {
             let font = format!("{family} {style}");
             let reason = match db.face(&family, &style) {
                 Some(f) if f.family.eq_ignore_ascii_case(&family) && f.embeddable() => {

crates/engine/src/cmd/panelcmds.rs

@@ -24,7 +24,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Character / Paragraph",
             [],
             None,
-            "{ids?|id?, kerning?: 1/1000 em|\"auto\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg, underline?, strikethrough?, allCaps?, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), leftIndent?, rightIndent?, firstLineIndent?, spaceBefore?, spaceAfter?: pt, hyphenate?: bool, mojikumi?: \"none\"|\"lineEndHalf\" (Japanese punctuation spacing), direction?: \"auto\"|\"leftToRight\"|\"rightToLeft\" (paragraph direction; auto: from each paragraph's first strong character)}",
+            "{ids?|id?, kerning?: 1/1000 em|\"auto\", baselineShift?: pt, hScale?: %, vScale?: %, rotation?: deg, underline?, strikethrough?, allCaps?, smallCaps?: bool, position?: \"normal\"|\"superscript\"|\"subscript\" (sizes from Document Setup), leftIndent?, rightIndent?, firstLineIndent?, spaceBefore?, spaceAfter?: pt, hyphenate?: bool, mojikumi?: \"none\"|\"lineEndHalf\" (Japanese punctuation spacing), direction?: \"auto\"|\"leftToRight\"|\"rightToLeft\" (paragraph direction; auto: from each paragraph's first strong character), leadingModel?: \"romanBaseline\"|\"emBoxTop\" (leading measured baseline to baseline, or em box top to top)}",
             has_doc,
             set_format
         ),
@@ -113,6 +113,7 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
         "hyphenate",
         "mojikumi",
         "direction",
+        "leadingModel",
     ];
     if !keys.iter().any(|k| p.get(*k).is_some()) {
         return Err(bad(C, "nothing to change"));
@@ -135,6 +136,14 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
             _ => return Err(bad(C, "`direction` must be \"auto\", \"leftToRight\" or \"rightToLeft\"")),
         }),
     };
+    let leading_model = match p.get("leadingModel") {
+        None => None,
+        Some(v) => Some(match v.as_str() {
+            Some("romanBaseline") => vectorcraft_doc::LeadingModel::RomanBaseline,
+            Some("emBoxTop") => vectorcraft_doc::LeadingModel::EmBoxTop,
+            _ => return Err(bad(C, "`leadingModel` must be \"romanBaseline\" or \"emBoxTop\"")),
+        }),
+    };
     s.edit("Character", |d, _| {
         for id in &ids {
             let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
@@ -196,6 +205,9 @@ fn set_format(s: &mut Session, p: &Value) -> Result<Value> {
             if let Some(v) = direction {
                 para.direction = v;
             }
+            if let Some(v) = leading_model {
+                para.leading_model = v;
+            }
             super::typecmd::refresh_bounds(t);
         }
         Ok(())

crates/engine/src/cmd/recovery.rs

@@ -13,9 +13,17 @@
 //!
 //! Every running app (each browser tab) keeps its copies in an area of its own, `<area>/…`, and
 //! holds it while it runs: a lock on the area for its lifetime where the store has locks (folders:
-//! [`FolderStore`]), else a heartbeat it refreshes ([`heartbeat`]; browser storage). Only areas
-//! nobody holds any more (their app is gone) are offered, and while their copies are restored or
-//! discarded the area is held, so two apps launched together never both take it.
+//! [`FolderStore`]), else a heartbeat it refreshes ([`heartbeat`]; browser storage) plus, where the
+//! store can, an announcement that lasts as long as the app ([`RecoveryStore::announce`]: the
+//! browser's Web Locks). Only areas nobody holds any more (their app is gone) are offered, and
+//! while their copies are restored or discarded the area is held, so two apps launched together
+//! never both take it.
+//!
+//! A heartbeat alone can't tell a gone app from one whose timers stopped (a background tab), so
+//! when unsure an area counts as held, and its app repairs what another app did meanwhile: each
+//! heartbeat and each recovery save write again the copies missing from its area ([`repair`]), and
+//! a heartbeat newer than the one another app wrote when taking the area over marks it running
+//! again.
 //!
 //! Each copy is two entries: `<area>/<file>.vectorcraft` (the native document, written as a save
 //! writes it) and `<area>/<file>.json` (its title, original path and format, and when it was
@@ -86,6 +94,17 @@ pub trait RecoveryStore: Send + Sync {
     fn lock(&self, _area: &str) -> std::result::Result<Lock, String> {
         Ok(Lock::Unsupported)
     }
+    /// Stores without locks: also hold area `area` in a way other apps can see that lasts exactly as
+    /// long as this app runs, if the store has one (the browser's Web Locks) → it, until dropped.
+    fn announce(&self, _area: &str) -> Option<Hold> {
+        None
+    }
+    /// Stores without locks: does a running app hold area `area` by [`RecoveryStore::announce`]?
+    /// `None`: the store can't tell (heartbeats alone decide). A store that can tell but isn't sure
+    /// right now says `Some(true)`: a copy kept loses nothing, one deleted may.
+    fn announced(&self, _area: &str) -> Option<bool> {
+        None
+    }
     /// Tidy away area `area` once it holds no copies and nobody holds it (its lock file and folder).
     fn remove_area(&self, _area: &str) {}
     /// The clock heartbeats are judged by (Unix seconds; `None`: none, so no area counts as gone).
@@ -96,17 +115,19 @@ pub trait RecoveryStore: Send + Sync {
 
 /// A store in memory (tests, and hosts without storage). Areas are locked in memory, so sessions
 /// sharing one store behave like apps sharing a folder; [`MemoryStore::without_locks`] uses
-/// heartbeats like browser storage, judged by a clock tests set ([`MemoryStore::set_now`]).
+/// heartbeats like browser storage, judged by a clock tests set ([`MemoryStore::set_now`]), and
+/// [`MemoryStore::announcing`] adds announcements like the browser's Web Locks.
 pub struct MemoryStore {
     entries: Mutex<BTreeMap<String, Vec<u8>>>,
     held: Arc<Mutex<BTreeSet<String>>>,
     locks: bool,
+    announces: bool,
     now: Mutex<Option<i64>>,
 }
 
 impl Default for MemoryStore {
     fn default() -> Self {
-        Self { entries: Default::default(), held: Default::default(), locks: true, now: Mutex::new(Some(1_000_000)) }
+        Self { entries: Default::default(), held: Default::default(), locks: true, announces: false, now: Mutex::new(Some(1_000_000)) }
     }
 }
 
@@ -116,6 +137,19 @@ impl MemoryStore {
         Self { locks: false, ..Self::default() }
     }
 
+    /// A store without locks whose apps also announce the areas they hold for as long as they run
+    /// (as the browser's Web Locks do).
+    pub fn announcing() -> Self {
+        Self { announces: true, ..Self::without_locks() }
+    }
+
+    fn hold(&self, area: &str) -> Option<Hold> {
+        if !self.held.lock().unwrap_or_else(|e| e.into_inner()).insert(area.to_string()) {
+            return None;
+        }
+        Some(Box::new(MemoryHold { held: self.held.clone(), area: area.to_string() }))
+    }
+
     /// Set the clock heartbeats are judged by.
     pub fn set_now(&self, t: i64) {
         *self.now.lock().unwrap_or_else(|e| e.into_inner()) = Some(t);
@@ -160,10 +194,16 @@ impl RecoveryStore for MemoryStore {
         if !self.locks {
             return Ok(Lock::Unsupported);
         }
-        if !self.held.lock().unwrap_or_else(|e| e.into_inner()).insert(area.to_string()) {
-            return Ok(Lock::Busy);
+        Ok(self.hold(area).map_or(Lock::Busy, Lock::Held))
+    }
+    fn announce(&self, area: &str) -> Option<Hold> {
+        if !self.announces {
+            return None;
         }
-        Ok(Lock::Held(Box::new(MemoryHold { held: self.held.clone(), area: area.to_string() })))
+        self.hold(area)
+    }
+    fn announced(&self, area: &str) -> Option<bool> {
+        self.announces.then(|| self.held.lock().unwrap_or_else(|e| e.into_inner()).contains(area))
     }
     fn now(&self) -> Option<i64> {
         *self.now.lock().unwrap_or_else(|e| e.into_inner())
@@ -288,8 +328,11 @@ struct Own {
     /// The store it is in (copies are removed from there even after the preference moves on).
     store: Arc<dyn RecoveryStore>,
     area: String,
-    /// The lock held for the session's lifetime; none in stores with heartbeats.
+    /// What holds the area for the session's lifetime: its lock, else its announcement (stores
+    /// without locks that have them).
     hold: Option<Hold>,
+    /// Held with a heartbeat (stores without locks).
+    beats: bool,
 }
 
 /// The session's recovery store settings and its own area ([`crate::Session::recovery`]).
@@ -300,9 +343,10 @@ pub struct Recovery {
     /// The folder the desktop app keeps copies in when the `recoveryFolder` preference is empty.
     default_folder: Option<String>,
     own: Option<Own>,
-    /// Gone apps' areas this session took over by heartbeat (stores without locks), so its own
-    /// fresh heartbeat there doesn't make them look running.
-    adopted: BTreeSet<String>,
+    /// Gone apps' areas this session took over by heartbeat (stores without locks), with the
+    /// heartbeat it wrote there: that one doesn't make them look running, a newer one does (their
+    /// app was only paused and came back).
+    adopted: BTreeMap<String, i64>,
 }
 
 impl Recovery {
@@ -354,31 +398,52 @@ fn stale_after(s: &Session) -> i64 {
     (i64::from(s.prefs.autosave_interval.max(1)) * 180).max(MIN_STALE)
 }
 
-/// Record that `area`'s app runs (stores without locks).
-fn beat(store: &dyn RecoveryStore, area: &str) -> std::result::Result<(), String> {
+/// Record that `area`'s app runs (stores without locks) → the heartbeat written.
+fn beat(store: &dyn RecoveryStore, area: &str) -> std::result::Result<i64, String> {
     let now = store.now().ok_or("no clock to keep a heartbeat by")?;
-    store.write(&format!("{area}/{BEAT}"), now.to_string().as_bytes())
+    store.write(&format!("{area}/{BEAT}"), now.to_string().as_bytes())?;
+    Ok(now)
 }
 
-/// Has `area`'s app said it runs within `stale` seconds (stores without locks)? Without a clock
-/// every app counts as running.
-fn beating(store: &dyn RecoveryStore, area: &str, stale: i64) -> bool {
+/// Has `area`'s app said it runs within `stale` seconds (stores without locks)? `mine`: the
+/// heartbeat this session wrote there itself when taking the area over, which doesn't count.
+/// Without a clock every app counts as running.
+fn beating(store: &dyn RecoveryStore, area: &str, stale: i64, mine: Option<i64>) -> bool {
     let Some(now) = store.now() else { return true };
     let at = store.read(&format!("{area}/{BEAT}")).ok().and_then(|b| String::from_utf8(b).ok()).and_then(|t| t.trim().parse::<i64>().ok());
-    at.is_some_and(|t| now.saturating_sub(t) <= stale)
+    at.is_some_and(|t| now.saturating_sub(t) <= stale && Some(t) != mine)
 }
 
-/// Refresh this session's heartbeat in a store without locks (the app does this every
-/// [`HEARTBEAT_EVERY`] seconds). Best effort: a missed beat only lets another app offer the copies
-/// once three intervals have passed.
-pub fn heartbeat(s: &Session) {
-    if let Some(own) = s.recovery.own.as_ref().filter(|o| o.hold.is_none()) {
+/// Refresh this session's hold on its area (the app does this every [`HEARTBEAT_EVERY`] seconds,
+/// so also on its first frame after its timers were paused): its heartbeat in a store without
+/// locks, and its copies ([`repair`]) → the documents whose copies went missing (write them now).
+/// Best effort: a missed beat only lets another app offer the copies once three intervals have
+/// passed.
+pub fn heartbeat(s: &mut Session) -> Vec<u64> {
+    if let Some(own) = s.recovery.own.as_ref().filter(|o| o.beats) {
         let _ = beat(own.store.as_ref(), &own.area);
     }
+    repair(s)
+}
+
+/// Forget this session's copies that are missing from its area, so the next recovery save writes
+/// them again → their documents' uids. Another app removes them only when it took this one for
+/// gone (its heartbeat stopped while its timers were paused, as browsers do to background tabs); a
+/// copy it restored is its own now, so both are kept. A store that can't be listed changes nothing.
+pub fn repair(s: &mut Session) -> Vec<u64> {
+    let Some(names) = s.recovery.own.as_ref().and_then(|o| o.store.list().ok()) else { return vec![] };
+    let mut lost = vec![];
+    for st in &mut s.docs {
+        if st.recovery.as_ref().is_some_and(|c| !names.iter().any(|n| n.strip_suffix(DOC_EXT) == Some(c.file.as_str()))) {
+            st.recovery = None;
+            lost.push(st.uid);
+        }
+    }
+    lost
 }
 
 /// This session's area in `store`, taken now if it has none there yet: a fresh area, held for the
-/// session's lifetime (locked, or with a heartbeat).
+/// session's lifetime (locked, or with a heartbeat and an announcement where the store has them).
 pub fn claim(s: &mut Session, store: &Arc<dyn RecoveryStore>) -> Result<String> {
     if let Some(own) = &s.recovery.own {
         if own.store.location() == store.location() {
@@ -394,15 +459,15 @@ pub fn claim(s: &mut Session, store: &Arc<dyn RecoveryStore>) -> Result<String>
         if taken.contains(&area) {
             continue;
         }
-        let hold = match store.lock(&area).map_err(EngineError::Other)? {
-            Lock::Held(h) => Some(h),
+        let (hold, beats) = match store.lock(&area).map_err(EngineError::Other)? {
+            Lock::Held(h) => (Some(h), false),
             Lock::Busy => continue,
             Lock::Unsupported => {
                 beat(store.as_ref(), &area).map_err(EngineError::Other)?;
-                None
+                (store.announce(&area), true)
             }
         };
-        s.recovery.own = Some(Own { store: store.clone(), area: area.clone(), hold });
+        s.recovery.own = Some(Own { store: store.clone(), area: area.clone(), hold, beats });
         return Ok(area);
     }
     Err(EngineError::Other("no free recovery area".into()))
@@ -413,7 +478,7 @@ pub fn release(s: &mut Session) {
     for st in &mut s.docs {
         st.recovery = None;
     }
-    let Some(Own { store, area, hold }) = s.recovery.own.take() else { return };
+    let Some(Own { store, area, hold, .. }) = s.recovery.own.take() else { return };
     let mine = |n: &String| n.split_once('/').is_some_and(|(a, _)| a == area);
     for name in store.list().unwrap_or_default().iter().filter(|n| mine(n)) {
         let _ = store.remove(name);
@@ -531,6 +596,8 @@ fn fresh_name(area: &str, stem: &str, taken: &[String]) -> String {
 /// when it has none and a copy is needed) → (jobs, skipped: `[{title, reason}]` for modified
 /// documents that get none).
 pub fn jobs(s: &mut Session, store: &Arc<dyn RecoveryStore>) -> Result<(Vec<RecoveryJob>, Vec<Value>)> {
+    // Copies another app removed are written again.
+    repair(s);
     let skipped: Vec<Value> = s
         .documents()
         .iter()
@@ -628,7 +695,9 @@ enum Owner {
 
 /// Whose `area` of `store` is. A gone app's area is held by the caller (its lock in `hold` until
 /// dropped) and, with `take` in a store without locks, taken over with a fresh heartbeat, so
-/// another app leaves it alone meanwhile.
+/// another app leaves it alone meanwhile. In a store without locks an area is gone only when
+/// nothing says its app runs: no announcement (or the store can't tell) and no heartbeat for three
+/// intervals but the one this session wrote taking it over.
 fn owner(s: &mut Session, store: &dyn RecoveryStore, area: &str, hold: &mut Vec<Hold>, take: bool) -> Owner {
     if s.recovery.own.as_ref().is_some_and(|o| o.area == area && o.store.location() == store.location()) {
         return Owner::Mine;
@@ -640,14 +709,12 @@ fn owner(s: &mut Session, store: &dyn RecoveryStore, area: &str, hold: &mut Vec<
         }
         Ok(Lock::Busy) | Err(_) => Owner::Running,
         Ok(Lock::Unsupported) => {
-            if !s.recovery.adopted.contains(area) && beating(store, area, stale_after(s)) {
+            if store.announced(area).unwrap_or(false) || beating(store, area, stale_after(s), s.recovery.adopted.get(area).copied()) {
                 return Owner::Running;
             }
-            if take {
-                // Best effort: without it another app might offer the copies too, which loses
-                // nothing.
-                let _ = beat(store, area);
-                s.recovery.adopted.insert(area.to_string());
+            // Best effort: without it another app might offer the copies too, which loses nothing.
+            if take && let Ok(t) = beat(store, area) {
+                s.recovery.adopted.insert(area.to_string(), t);
             }
             Owner::Gone
         }

crates/engine/src/cmd/typecmd.rs

@@ -408,6 +408,31 @@ fn reshape_area(s: &mut Session, p: &Value) -> Result<Value> {
 mod area_tests {
     use super::*;
 
+    #[test]
+    fn leading_model_is_set_per_paragraph_and_saved_only_when_top_to_top() {
+        use vectorcraft_doc::LeadingModel;
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+        let id = s.execute("text.create", &json!({"x": 10, "y": 10, "text": "一\n二", "area": {"width": 200, "height": 100}})).unwrap()["id"]
+            .as_u64()
+            .unwrap();
+        let text = |s: &Session| match &s.doc().unwrap().doc.node(NodeId(id)).unwrap().kind {
+            NodeKind::Text(t) => (**t).clone(),
+            _ => panic!("text"),
+        };
+        assert_eq!(text(&s).para.leading_model, LeadingModel::RomanBaseline);
+        s.execute("select.set", &json!({"ids": [id]})).unwrap();
+        assert!(s.execute("text.setFormat", &json!({"leadingModel": "middle"})).is_err());
+        let before = text(&s).cached_bounds;
+        s.execute("text.setFormat", &json!({"leadingModel": "emBoxTop"})).unwrap();
+        let t = text(&s);
+        assert_eq!(t.para.leading_model, LeadingModel::EmBoxTop);
+        assert_ne!(t.cached_bounds, before, "the first line moves up to the frame's top");
+        assert_eq!(serde_json::to_value(&t.para).unwrap()["leading_model"], "emBoxTop");
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert!(serde_json::to_value(&text(&s).para).unwrap().get("leading_model").is_none());
+    }
+
     #[test]
     fn new_type_is_composed_with_line_end_half_width_punctuation() {
         use vectorcraft_doc::Mojikumi;

crates/engine/src/lib.rs

@@ -79,8 +79,10 @@ pub struct Interaction {
     pub doc: Arc<Document>,
     pub selection: Selection,
     pub preview: Option<(String, Value)>,
-    /// Per-document state restored on cancel (current layer, isolation).
+    /// Per-document state restored on cancel (current layer, highlighted Layers panel rows,
+    /// isolation).
     pub active_layer: Option<NodeId>,
+    pub layer_rows: Vec<NodeId>,
     pub isolation: Option<NodeId>,
     /// The perspective transform the previews make (`perspective.transform` params): Transform
     /// Again repeats it once the drag is committed.
@@ -206,6 +208,7 @@ impl DocState {
             self.doc = it.doc;
             self.selection = it.selection;
             self.active_layer = it.active_layer;
+            self.layer_rows = it.layer_rows;
             self.isolation = it.isolation;
             self.revision += 1;
         }
@@ -1114,6 +1117,7 @@ impl Session {
             selection: st.selection.clone(),
             preview: None,
             active_layer: st.active_layer,
+            layer_rows: st.layer_rows.clone(),
             isolation: st.isolation,
             perspective_again: None,
         });
@@ -1301,6 +1305,8 @@ mod tests_liquify;
 #[cfg(test)]
 mod tests_live;
 #[cfg(test)]
+mod tests_livecorners;
+#[cfg(test)]
 mod tests_maskview;
 #[cfg(test)]
 mod tests_menucmds;

crates/engine/src/tests_build.rs

@@ -172,6 +172,154 @@ fn shape_builder_tool_drives_the_command() {
     assert_eq!(layer_children(&s), 1);
 }
 
+/// A red 100 × 100 square crossed by a stroke-only vertical line at x = 50, both selected.
+fn square_and_line(s: &mut Session) -> (NodeId, NodeId) {
+    let a = rect(s, 0.0, 0.0, 100.0, 100.0);
+    set_fill(s, a, Color::rgb(1.0, 0.0, 0.0));
+    let l = line(s, (50.0, -20.0), (50.0, 120.0));
+    s.execute("select.set", &json!({"ids": [a.0, l.0]})).unwrap();
+    (a, l)
+}
+
+/// The open paths among `ids`, as (anchors, bounds).
+fn open_paths(s: &Session, ids: &[NodeId]) -> Vec<(usize, Rect)> {
+    ids.iter()
+        .map(|i| node(s, *i))
+        .filter(|n| !outline(n).0.is_closed())
+        .map(|n| (outline(&n).0.anchor_count(), n.geometric_bounds().unwrap()))
+        .collect()
+}
+
+#[test]
+fn shape_builder_line_splits_a_shape_into_regions() {
+    let mut s = session();
+    let (a, l) = square_and_line(&mut s);
+    let r = s.execute("shapeBuilder.regions", &json!({})).unwrap();
+    let regs = r["regions"].as_array().unwrap();
+    assert_eq!(regs.len(), 2, "{r}");
+    for x in regs {
+        assert!((x["area"].as_f64().unwrap() - 5000.0).abs() < 1e-6);
+        assert_eq!(x["sources"], json!([a.0]));
+    }
+    let lines = r["lines"].as_array().unwrap();
+    assert_eq!(lines.len(), 3, "the line cut at both sides of the square");
+    assert!(lines.iter().all(|x| x["source"] == l.0));
+}
+
+#[test]
+fn shape_builder_click_on_a_side_of_a_line_splits_the_shape() {
+    let mut s = session();
+    square_and_line(&mut s);
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[25, 50]]})).unwrap();
+    assert_eq!(r["regions"], 1);
+    let out = ids(&r);
+    let merged = NodeId(r["merged"].as_u64().unwrap());
+    assert_eq!(node(&s, merged).geometric_bounds().unwrap(), Rect::new(0.0, 0.0, 50.0, 100.0));
+    assert_eq!(node(&s, merged).appearance.fill_paint(), Paint::solid(Color::rgb(1.0, 0.0, 0.0)));
+    let closed: Vec<f64> = out.iter().filter(|i| outline(&node(&s, **i)).0.is_closed()).map(|i| area(&s, *i)).collect();
+    assert_eq!(closed.len(), 2, "both halves");
+    assert!(closed.iter().all(|a| (a - 5000.0).abs() < 1.0), "{closed:?}");
+    // The line only bounds the region: it stays whole.
+    assert_eq!(open_paths(&s, &out), vec![(2, Rect::new(50.0, -20.0, 50.0, 120.0))]);
+}
+
+#[test]
+fn shape_builder_merge_across_a_line_removes_the_piece_between() {
+    let mut s = session();
+    square_and_line(&mut s);
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[25, 50], [75, 50]]})).unwrap();
+    assert_eq!(r["regions"], 2);
+    let out = ids(&r);
+    let merged = NodeId(r["merged"].as_u64().unwrap());
+    assert!((area(&s, merged) - 10000.0).abs() < 1.0);
+    assert_eq!(out.len(), 3, "merged square + the line's two loose ends");
+    let mut ends = open_paths(&s, &out);
+    ends.sort_by(|a, b| a.1.y0.total_cmp(&b.1.y0));
+    assert_eq!(ends, vec![(2, Rect::new(50.0, -20.0, 50.0, 0.0)), (2, Rect::new(50.0, 100.0, 50.0, 120.0))]);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(layer_children(&s), 2);
+}
+
+#[test]
+fn shape_builder_alt_deletes_a_region_or_a_line_piece() {
+    let mut s = session();
+    square_and_line(&mut s);
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[75, 50]], "erase": true})).unwrap();
+    assert!(r["merged"].is_null());
+    let out = ids(&r);
+    let left: Vec<NodeId> = out.iter().copied().filter(|i| outline(&node(&s, *i)).0.is_closed()).collect();
+    assert_eq!(left.len(), 1);
+    assert_eq!(node(&s, left[0]).geometric_bounds().unwrap(), Rect::new(0.0, 0.0, 50.0, 100.0));
+    assert_eq!(open_paths(&s, &out).len(), 1, "the line stays whole");
+
+    // Alt on the line inside the square deletes that piece only.
+    let mut s = session();
+    square_and_line(&mut s);
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[51, 50]], "erase": true, "tolerance": 2})).unwrap();
+    assert_eq!((r["regions"].as_u64(), r["lines"].as_u64()), (Some(0), Some(1)));
+    let out = ids(&r);
+    assert_eq!(out.len(), 3);
+    let sq: Vec<NodeId> = out.iter().copied().filter(|i| outline(&node(&s, *i)).0.is_closed()).collect();
+    assert_eq!(sq.len(), 1);
+    assert!((area(&s, sq[0]) - 10000.0).abs() < 1.0, "the square is untouched");
+    assert_eq!(open_paths(&s, &out).len(), 2);
+}
+
+#[test]
+fn shape_builder_fills_an_area_lines_enclose() {
+    let mut s = session();
+    let l1 = line(&mut s, (0.0, 0.0), (100.0, 100.0));
+    let l2 = line(&mut s, (100.0, 0.0), (0.0, 100.0));
+    let l3 = line(&mut s, (-10.0, 80.0), (110.0, 80.0));
+    s.execute("select.set", &json!({"ids": [l1.0, l2.0, l3.0]})).unwrap();
+    let r = s.execute("shapeBuilder.regions", &json!({})).unwrap();
+    assert_eq!(r["regions"].as_array().unwrap().len(), 1);
+    assert_eq!(r["regions"][0]["sources"], json!([]));
+    let r = s.execute("shapeBuilder.merge", &json!({"points": [[50, 70]]})).unwrap();
+    let merged = NodeId(r["merged"].as_u64().unwrap());
+    assert!((area(&s, merged) - 900.0).abs() < 1e-6, "{}", area(&s, merged));
+    assert_eq!(node(&s, merged).appearance.fill_paint(), s.paint.fill, "the current fill");
+    assert!(!node(&s, merged).appearance.stroke_paint().is_none(), "the lines' stroke");
+    assert_eq!(ids(&r).len(), 4, "the triangle + the three lines, which only bound it");
+}
+
+#[test]
+fn shape_builder_closes_filled_open_paths() {
+    let mut s = session();
+    let r = s.execute("path.create", &json!({"anchors": [{"x": 0, "y": 0}, {"x": 100, "y": 0}, {"x": 100, "y": 100}]})).unwrap();
+    let p = NodeId(r["id"].as_u64().unwrap());
+    set_fill(&mut s, p, Color::rgb(0.0, 1.0, 0.0));
+    s.execute("select.set", &json!({"ids": [p.0]})).unwrap();
+    let r = s.execute("shapeBuilder.regions", &json!({})).unwrap();
+    assert_eq!(r["regions"].as_array().unwrap().len(), 1, "the fill's area, closed by an invisible edge");
+    assert!((r["regions"][0]["area"].as_f64().unwrap() - 5000.0).abs() < 1e-6);
+    assert_eq!(r["lines"], json!([]));
+    // Unfilled, it is only an edge.
+    s.edit("t", |d, _| {
+        d.node_mut(p).unwrap().appearance.set_fill(Paint::None);
+        Ok(())
+    })
+    .unwrap();
+    let r = s.execute("shapeBuilder.regions", &json!({})).unwrap();
+    assert_eq!(r["regions"], json!([]));
+    assert_eq!(r["lines"].as_array().unwrap().len(), 1);
+}
+
+#[test]
+fn shape_builder_tool_alt_deletes_line_pieces() {
+    let mut s = session();
+    square_and_line(&mut s);
+    let v = ViewInfo::default();
+    s.select_tool("shapeBuilder", v).unwrap();
+    let alt = Mods { alt: true, ..Default::default() };
+    s.pointer(&PointerEvent::new(PointerKind::Move, 51.0, 50.0).with_mods(alt), v).unwrap();
+    assert_eq!(s.overlays(v).len(), 1, "the line piece is highlighted");
+    s.pointer(&PointerEvent::new(PointerKind::Down, 51.0, 50.0).with_mods(alt), v).unwrap();
+    s.pointer(&PointerEvent::new(PointerKind::Up, 51.0, 50.0).with_mods(alt), v).unwrap();
+    assert_eq!(s.journal.last().unwrap().0, "shapeBuilder.merge");
+    assert_eq!(layer_children(&s), 3, "square + the line's two loose ends");
+}
+
 // ---------- Live Paint ----------
 
 fn live(s: &mut Session) -> NodeId {

crates/engine/src/tests_journal.rs

@@ -231,3 +231,21 @@ fn a_failed_batch_brings_back_a_document_it_reverted() {
     assert!(st.is_dirty() && st.interaction.is_none());
     assert!(st.revision > revision, "the restored document redraws");
 }
+
+#[test]
+fn a_failed_batch_gives_back_the_highlighted_rows_and_the_current_layer() {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"created": null})).unwrap();
+    let layer = s.doc().unwrap().doc.layers[0].id;
+    // A step that highlights the layer's row, then one that fails: the highlight goes back too.
+    let steps = json!([{"command": "layer.setCurrent", "params": {"id": layer.0}}, {"command": "no.such.command"}]);
+    assert!(s.execute("command.batch", &json!({ "commands": steps })).is_err());
+    assert!(s.doc().unwrap().layer_rows.is_empty(), "no row stays highlighted");
+    assert_eq!(s.doc().unwrap().active_layer, Some(layer));
+    // So Collect in New Layer acts on the drawn rectangle, as it does when the journal is replayed
+    // (a failed batch isn't journaled).
+    s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 1, "height": 1})).unwrap();
+    s.execute("layer.collectInNew", &json!({})).unwrap();
+    let r = replayed(&s);
+    assert_eq!(documents(&r), documents(&s));
+}

crates/engine/src/tests_livecorners.rs

@@ -0,0 +1,107 @@
+//! Live Corners on live rectangles: `object.setLiveShape` rounds the given corners, the
+//! Direct-Selected ones or all four, sets corner kinds, and keeps selected corners selected.
+
+use std::collections::BTreeSet;
+
+use serde_json::{Value, json};
+use vectorcraft_doc::{AnchorRef, LiveShape, NodeKind};
+use vectorcraft_geom::shapes::CornerKind;
+
+use super::*;
+
+/// A 100 × 60 pt live rectangle at (10, 10), selected.
+fn session() -> (Session, NodeId) {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+    let id = s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 100, "height": 60})).unwrap()["id"].as_u64().unwrap();
+    (s, NodeId(id))
+}
+
+fn run(s: &mut Session, p: Value) {
+    s.execute("object.setLiveShape", &p).unwrap_or_else(|e| panic!("{p}: {e}"));
+}
+
+fn corners(s: &Session, id: NodeId) -> ([f64; 4], [CornerKind; 4], usize) {
+    let n = s.doc().unwrap().doc.node(id).unwrap();
+    let NodeKind::Path { live: Some(LiveShape::Rectangle { radii, kinds, .. }), path, .. } = &n.kind else { panic!("not a live rectangle") };
+    (*radii, *kinds, path.anchor_count())
+}
+
+fn selected_anchors(s: &Session, id: NodeId) -> Option<BTreeSet<AnchorRef>> {
+    s.doc().unwrap().selection.partial(id).cloned()
+}
+
+fn anchors(v: &[usize]) -> BTreeSet<AnchorRef> {
+    v.iter().map(|ai| (0, *ai)).collect()
+}
+
+#[test]
+fn a_whole_rectangle_rounds_all_corners_and_given_corners_alone() {
+    let (mut s, id) = session();
+    run(&mut s, json!({"radius": 8}));
+    assert_eq!(corners(&s, id), ([8.0; 4], [CornerKind::Round; 4], 8));
+    run(&mut s, json!({"id": id.0, "radius": 0}));
+    // One corner: only it rounds, and the path gains one anchor (one undo step).
+    let undo = s.doc().unwrap().history.undo.len();
+    run(&mut s, json!({"ids": [id.0], "corners": [1], "radius": 12}));
+    assert_eq!(corners(&s, id), ([0.0, 12.0, 0.0, 0.0], [CornerKind::Round; 4], 5));
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
+    let b = s.doc().unwrap().doc.node(id).unwrap().geometric_bounds().unwrap();
+    assert!((b.x1 - 110.0).abs() < 1e-9 && (b.y0 - 10.0).abs() < 1e-9, "the shape keeps its bounds: {b:?}");
+    // Kinds alone, then both; the others stay as they were.
+    run(&mut s, json!({"corners": [1, 3], "kind": "chamfer"}));
+    run(&mut s, json!({"corners": [3], "radius": 5, "kind": "invertedRound"}));
+    assert_eq!(corners(&s, id), ([0.0, 12.0, 0.0, 5.0], [CornerKind::Round, CornerKind::Chamfer, CornerKind::Round, CornerKind::InvertedRound], 6));
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(corners(&s, id).1[3], CornerKind::Chamfer);
+}
+
+#[test]
+fn bad_corners_and_kinds_are_errors() {
+    let (mut s, id) = session();
+    for p in
+        [json!({"corners": [4], "radius": 5}), json!({"corners": ["a"]}), json!({"corners": 1}), json!({"corners": [-1]}), json!({"kind": "wavy"})]
+    {
+        assert!(s.execute("object.setLiveShape", &p).is_err(), "{p}");
+    }
+    assert_eq!(corners(&s, id), ([0.0; 4], [CornerKind::Round; 4], 4), "nothing changed");
+}
+
+#[test]
+fn direct_selected_corners_round_alone_and_stay_selected() {
+    let (mut s, id) = session();
+    // Direct Selection picks the top-right and bottom-left corners.
+    s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 1], [0, 3]], "mode": "set"})).unwrap();
+    run(&mut s, json!({"radius": 10}));
+    assert_eq!(corners(&s, id), ([0.0, 10.0, 0.0, 10.0], [CornerKind::Round; 4], 6));
+    // Anchors: top-left, top-right's two, bottom-right, bottom-left's two.
+    assert_eq!(selected_anchors(&s, id), Some(anchors(&[1, 2, 4, 5])));
+    // The same corners again (a field in the Properties panel), now with their two anchors each.
+    run(&mut s, json!({"kind": "chamfer"}));
+    assert_eq!(corners(&s, id).1, [CornerKind::Round, CornerKind::Chamfer, CornerKind::Round, CornerKind::Chamfer]);
+    run(&mut s, json!({"radius": 0}));
+    assert_eq!(corners(&s, id).2, 4);
+    assert_eq!(selected_anchors(&s, id), Some(anchors(&[1, 3])));
+    // Undo brings back the selection with the shape.
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(selected_anchors(&s, id), Some(anchors(&[1, 2, 4, 5])));
+    // Explicit corners win over the selection, which follows its own corners.
+    run(&mut s, json!({"corners": [0], "radius": 4}));
+    assert_eq!(corners(&s, id).0, [4.0, 10.0, 0.0, 10.0]);
+    assert_eq!(selected_anchors(&s, id), Some(anchors(&[1, 2, 4, 5])), "the top-left corner comes first and last");
+}
+
+#[test]
+fn a_drag_previews_one_corner_and_commits_one_step() {
+    let (mut s, id) = session();
+    s.execute("select.anchors", &json!({"id": id.0, "anchors": [[0, 2]], "mode": "set"})).unwrap();
+    let undo = s.doc().unwrap().history.undo.len();
+    s.begin_interaction("Corner Radius").unwrap();
+    for r in [5.0, 9.0, 14.0] {
+        s.preview("object.setLiveShape", &json!({"id": id.0, "radius": r, "corners": [2]})).unwrap();
+    }
+    s.commit_interaction().unwrap();
+    assert_eq!(corners(&s, id), ([0.0, 0.0, 14.0, 0.0], [CornerKind::Round; 4], 5));
+    assert_eq!(selected_anchors(&s, id), Some(anchors(&[2, 3])));
+    assert_eq!(s.doc().unwrap().history.undo.len(), undo + 1);
+}

crates/engine/src/tests_recovery.rs

@@ -1,6 +1,7 @@
 //! Data Recovery: `file.recovery.save/list/restore/discard`, copies removed on save, revert and
 //! close, complex documents skipped, each app's own area (another running app's copies are never
-//! offered: locks, heartbeats), and the folder store with real file locks.
+//! offered: locks, heartbeats, announcements; a paused app repairs its copies), and the folder
+//! store with real file locks.
 
 use std::sync::Arc;
 
@@ -175,7 +176,7 @@ fn heartbeats_hold_areas_where_the_store_has_no_locks() {
     store.set_now(10_000 + 359);
     assert!(offered(&mut b).is_empty());
     // A beats (as the app does every minute): fresh again.
-    cmd::recovery::heartbeat(&a);
+    cmd::recovery::heartbeat(&mut a);
     store.set_now(10_000 + 359 + 300);
     assert!(offered(&mut b).is_empty());
     assert_eq!(restored(b.execute("file.recovery.restore", &json!({})).unwrap()), 0);
@@ -203,6 +204,71 @@ fn heartbeats_hold_areas_where_the_store_has_no_locks() {
     assert_eq!(offered(&mut b), ["Untitled-1"]);
 }
 
+/// Issue #367: a tab whose timers were paused (a background tab) long enough for its heartbeat to
+/// go stale, while another tab discards the copies it takes for crash leftovers.
+#[test]
+fn a_paused_app_writes_its_copies_again_and_is_running_again() {
+    let store = Arc::new(MemoryStore::without_locks());
+    let mut a = session_in(&store);
+    a.execute("file.recovery.save", &json!({})).unwrap();
+    let a_file = format!("{}/Untitled-1-1", a.recovery.own_area().unwrap());
+    let mut b = relaunch(&store);
+    b.prefs.autosave_interval = 1;
+    assert!(b.execute("file.recovery.discard", &json!({})).unwrap()["discarded"].as_array().unwrap().is_empty());
+    // A is paused past three minutes: with heartbeats alone, B can't tell it from a crash.
+    store.set_now(1_000_000 + 186);
+    assert_eq!(b.execute("file.recovery.discard", &json!({})).unwrap()["discarded"], json!([a_file.clone()]));
+    assert!(copies(store.as_ref()).is_empty());
+    // A resumes: its heartbeat finds the copy gone and the next save writes it again, unchanged
+    // document or not.
+    store.set_now(1_000_000 + 200);
+    assert_eq!(cmd::recovery::heartbeat(&mut a), [a.doc().unwrap().uid]);
+    assert!(a.doc().unwrap().recovery.is_none());
+    let r = a.execute("file.recovery.save", &json!({})).unwrap();
+    assert_eq!(r["saved"][0]["file"], a_file.as_str(), "{r}");
+    assert_eq!(copies(store.as_ref()), ["Untitled-1-1"]);
+    assert!(cmd::recovery::heartbeat(&mut a).is_empty(), "nothing missing any more");
+    // A's heartbeat is newer than the one B wrote taking the area over: A runs again for B.
+    let l = b.execute("file.recovery.list", &json!({})).unwrap();
+    assert_eq!((l["copies"][0]["file"].as_str(), l["copies"][0]["running"].as_bool()), (Some(a_file.as_str()), Some(true)));
+    assert!(b.execute("file.recovery.discard", &json!({})).unwrap()["discarded"].as_array().unwrap().is_empty());
+    assert!(b.execute("file.recovery.discard", &json!({"file": a_file})).is_err());
+    // A recovery save alone repairs too (no heartbeat in between).
+    store.set_now(1_000_000 + 600);
+    let mut c = relaunch(&store);
+    c.prefs.autosave_interval = 1;
+    c.execute("file.recovery.discard", &json!({})).unwrap();
+    assert!(copies(store.as_ref()).is_empty());
+    assert_eq!(a.execute("file.recovery.save", &json!({})).unwrap()["saved"].as_array().unwrap().len(), 1);
+    assert_eq!(copies(store.as_ref()), ["Untitled-1-1"]);
+}
+
+/// Issue #367 where the store can tell a paused app from a gone one (the browser's Web Locks): the
+/// paused app's copies are never taken, however old its heartbeat.
+#[test]
+fn announced_areas_stay_held_while_their_app_is_paused() {
+    let store = Arc::new(MemoryStore::announcing());
+    let mut a = session_in(&store);
+    a.execute("file.recovery.save", &json!({})).unwrap();
+    let a_file = format!("{}/Untitled-1-1", a.recovery.own_area().unwrap());
+    store.set_now(1_000_000 + 3600);
+    let mut b = relaunch(&store);
+    assert!(offered(&mut b).is_empty());
+    assert!(b.execute("file.recovery.discard", &json!({})).unwrap()["discarded"].as_array().unwrap().is_empty());
+    assert_eq!(restored(b.execute("file.recovery.restore", &json!({})).unwrap()), 0);
+    assert!(b.execute("file.recovery.discard", &json!({"file": a_file})).unwrap_err().to_string().contains("running"));
+    assert_eq!(copies(store.as_ref()), ["Untitled-1-1"]);
+    // A crashes: the browser releases its lock, and its copies are offered once its heartbeat is
+    // stale too.
+    drop(a);
+    assert_eq!(offered(&mut b), ["Untitled-1"]);
+    assert_eq!(restored(b.execute("file.recovery.restore", &json!({})).unwrap()), 1);
+    // B's area is announced in turn.
+    let mut c = relaunch(&store);
+    store.set_now(1_000_000 + 7200);
+    assert!(offered(&mut c).is_empty());
+}
+
 #[test]
 fn folder_areas_are_locked_by_running_apps() {
     let dir = std::env::temp_dir().join(format!("vc-recovery-locks-{}", std::process::id()));

crates/geom/src/shapes.rs

@@ -3,6 +3,7 @@
 use std::f64::consts::{PI, TAU};
 
 use kurbo::{Point, Rect, Vec2};
+use serde::{Deserialize, Serialize};
 
 use crate::path::{Anchor, AnchorKind, PathData, SubPath};
 
@@ -17,25 +18,85 @@ pub fn rectangle(r: Rect) -> PathData {
 
 /// Rounded rectangle (8 anchors). The radius is clamped to half the shorter side.
 pub fn rounded_rectangle(r: Rect, radius: f64) -> PathData {
-    let r = r.abs();
-    let rad = radius.max(0.0).min(r.width() / 2.0).min(r.height() / 2.0);
-    if rad <= 1e-9 {
-        return rectangle(r);
+    rectangle_with_corners(r, [radius; 4], [CornerKind::Round; 4])
+}
+
+/// How a rectangle's corner is cut (Live Corners).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum CornerKind {
+    /// A quarter circle, bulging outwards.
+    #[default]
+    Round,
+    /// A quarter circle cut into the shape, centred on the corner.
+    InvertedRound,
+    /// A straight bevel.
+    Chamfer,
+}
+
+impl CornerKind {
+    pub const ALL: [CornerKind; 3] = [CornerKind::Round, CornerKind::InvertedRound, CornerKind::Chamfer];
+
+    /// The kind after this one (Alt-clicking a corner widget cycles through them).
+    pub fn next(self) -> Self {
+        match self {
+            CornerKind::Round => CornerKind::InvertedRound,
+            CornerKind::InvertedRound => CornerKind::Chamfer,
+            CornerKind::Chamfer => CornerKind::Round,
+        }
     }
-    let k = rad * KAPPA;
-    let (x0, y0, x1, y1) = (r.x0, r.y0, r.x1, r.y1);
-    let a = |p: (f64, f64), hin: (f64, f64), hout: (f64, f64)| Anchor { p: p.into(), h_in: hin.into(), h_out: hout.into(), kind: AnchorKind::Corner };
-    let anchors = vec![
-        a((x0 + rad, y0), (x0 + rad - k, y0), (x0 + rad, y0)),
-        a((x1 - rad, y0), (x1 - rad, y0), (x1 - rad + k, y0)),
-        a((x1, y0 + rad), (x1, y0 + rad - k), (x1, y0 + rad)),
-        a((x1, y1 - rad), (x1, y1 - rad), (x1, y1 - rad + k)),
-        a((x1 - rad, y1), (x1 - rad + k, y1), (x1 - rad, y1)),
-        a((x0 + rad, y1), (x0 + rad, y1), (x0 + rad - k, y1)),
-        a((x0, y1 - rad), (x0, y1 - rad + k), (x0, y1 - rad)),
-        a((x0, y0 + rad), (x0, y0 + rad), (x0, y0 + rad - k)),
+}
+
+/// Rectangle whose corners (top-left, top-right, bottom-right, bottom-left, y down) each have
+/// their own radius and kind, every radius clamped to half the shorter side. A corner without a
+/// radius is one anchor, the others two (where the cut meets each side). Clockwise from the
+/// top-left corner, its anchor on the top side first.
+pub fn rectangle_with_corners(r: Rect, radii: [f64; 4], kinds: [CornerKind; 4]) -> PathData {
+    PathData::single(SubPath::new(corner_anchors(r, radii, kinds).into_iter().map(|(_, a)| a).collect(), true))
+}
+
+/// The corner (index into `radii`) of each anchor of [`rectangle_with_corners`].
+pub fn rectangle_anchor_corners(r: Rect, radii: [f64; 4]) -> Vec<usize> {
+    corner_anchors(r, radii, [CornerKind::Round; 4]).into_iter().map(|(k, _)| k).collect()
+}
+
+/// The anchors of [`rectangle_with_corners`], each with its corner.
+fn corner_anchors(r: Rect, radii: [f64; 4], kinds: [CornerKind; 4]) -> Vec<(usize, Anchor)> {
+    let r = r.abs();
+    let max = r.width().min(r.height()) / 2.0;
+    // Each corner, with the directions of the side arriving at it and of the side leaving it.
+    let corners = [
+        (Point::new(r.x0, r.y0), Vec2::new(0.0, -1.0), Vec2::new(1.0, 0.0)),
+        (Point::new(r.x1, r.y0), Vec2::new(1.0, 0.0), Vec2::new(0.0, 1.0)),
+        (Point::new(r.x1, r.y1), Vec2::new(0.0, 1.0), Vec2::new(-1.0, 0.0)),
+        (Point::new(r.x0, r.y1), Vec2::new(-1.0, 0.0), Vec2::new(0.0, -1.0)),
     ];
-    PathData::single(SubPath::new(anchors, true))
+    let mut out = Vec::with_capacity(8);
+    let mut top_left_start = None;
+    for (k, ((c, din, dout), (rad, kind))) in corners.into_iter().zip(radii.into_iter().zip(kinds)).enumerate() {
+        let rad = rad.max(0.0).min(max);
+        if rad <= 1e-9 {
+            out.push((k, Anchor::corner(c)));
+            continue;
+        }
+        // The cut runs from `start` on the arriving side to `end` on the leaving one.
+        let (start, end, h) = (c - din * rad, c + dout * rad, rad * KAPPA);
+        let (h_out, h_in) = match kind {
+            CornerKind::Round => (start + din * h, end - dout * h),
+            CornerKind::InvertedRound => (start + dout * h, end - din * h),
+            CornerKind::Chamfer => (start, end),
+        };
+        let start = Anchor { p: start, h_in: start, h_out, kind: AnchorKind::Corner };
+        let end = Anchor { p: end, h_in, h_out: end, kind: AnchorKind::Corner };
+        if k == 0 {
+            top_left_start = Some(start);
+        } else {
+            out.push((k, start));
+        }
+        out.push((k, end));
+    }
+    out.extend(top_left_start.map(|a| (0, a)));
+    out
 }
 
 /// Ellipse inscribed in `r` with 4 smooth anchors (left, top, right, bottom).
@@ -203,6 +264,54 @@ mod tests {
         assert_eq!(rounded_rectangle(Rect::new(0.0, 0.0, 20.0, 10.0), 0.0).anchor_count(), 4);
     }
 
+    #[test]
+    fn uniform_corners_keep_the_rounded_rectangle_layout() {
+        // The 8 anchors a rounded rectangle always had, from the top side's first one.
+        let (r, rad) = (Rect::new(10.0, 20.0, 110.0, 70.0), 7.5);
+        let (x0, y0, x1, y1, k) = (10.0, 20.0, 110.0, 70.0, rad * KAPPA);
+        let a =
+            |p: (f64, f64), hin: (f64, f64), hout: (f64, f64)| Anchor { p: p.into(), h_in: hin.into(), h_out: hout.into(), kind: AnchorKind::Corner };
+        let want = vec![
+            a((x0 + rad, y0), (x0 + rad - k, y0), (x0 + rad, y0)),
+            a((x1 - rad, y0), (x1 - rad, y0), (x1 - rad + k, y0)),
+            a((x1, y0 + rad), (x1, y0 + rad - k), (x1, y0 + rad)),
+            a((x1, y1 - rad), (x1, y1 - rad), (x1, y1 - rad + k)),
+            a((x1 - rad, y1), (x1 - rad + k, y1), (x1 - rad, y1)),
+            a((x0 + rad, y1), (x0 + rad, y1), (x0 + rad - k, y1)),
+            a((x0, y1 - rad), (x0, y1 - rad + k), (x0, y1 - rad)),
+            a((x0, y0 + rad), (x0, y0 + rad), (x0, y0 + rad - k)),
+        ];
+        assert_eq!(rounded_rectangle(r, rad).subpaths[0].anchors, want);
+        assert_eq!(rectangle_anchor_corners(r, [rad; 4]), [0, 1, 1, 2, 2, 3, 3, 0]);
+        assert_eq!(rounded_rectangle(r, 0.0), rectangle(r));
+    }
+
+    #[test]
+    fn each_corner_takes_its_own_radius_and_kind() {
+        let r = Rect::new(0.0, 0.0, 100.0, 60.0);
+        // Only the top-right corner rounded: 5 anchors, the corner's two on its sides.
+        let radii = [0.0, 10.0, 0.0, 0.0];
+        let p = rectangle_with_corners(r, radii, [CornerKind::Round; 4]);
+        let pts: Vec<Point> = p.subpaths[0].anchors.iter().map(|a| a.p).collect();
+        assert_eq!(pts, [Point::new(0.0, 0.0), Point::new(90.0, 0.0), Point::new(100.0, 10.0), Point::new(100.0, 60.0), Point::new(0.0, 60.0)]);
+        assert_eq!(rectangle_anchor_corners(r, radii), [0, 1, 1, 2, 3]);
+        let quarter = PI * 25.0;
+        assert!((p.subpaths[0].area() - (6000.0 - 100.0 + quarter)).abs() < 0.1, "a quarter circle off one corner");
+        // The top-left corner rounded: its top-side anchor first, its left-side one last.
+        assert_eq!(rectangle_anchor_corners(r, [10.0, 0.0, 0.0, 200.0]), [0, 1, 2, 3, 3, 0]);
+        // Inverted round cuts a quarter circle out; a chamfer cuts a triangle.
+        let inverted = rectangle_with_corners(r, radii, [CornerKind::InvertedRound; 4]);
+        assert!((inverted.subpaths[0].area() - (6000.0 - quarter)).abs() < 0.1);
+        let chamfer = rectangle_with_corners(r, radii, [CornerKind::Chamfer; 4]);
+        assert!((chamfer.subpaths[0].area() - (6000.0 - 50.0)).abs() < 1e-9);
+        assert!(chamfer.subpaths[0].anchors.iter().all(|a| !a.has_in() && !a.has_out()), "straight");
+        // Radii clamp to half the shorter side; negative and NaN radii are none.
+        let p = rectangle_with_corners(r, [500.0, -5.0, f64::NAN, 0.0], [CornerKind::Round; 4]);
+        assert_eq!(p.subpaths[0].anchors[0].p, Point::new(30.0, 0.0));
+        assert_eq!(p.anchor_count(), 5);
+        assert_eq!(CornerKind::ALL.map(CornerKind::next), [CornerKind::InvertedRound, CornerKind::Chamfer, CornerKind::Round]);
+    }
+
     #[test]
     fn polygon_first_vertex_up() {
         let p = polygon(Point::new(0.0, 0.0), 10.0, 6, 0.0);

crates/pathops/README.md

@@ -35,6 +35,7 @@ pub struct Region { pub path: PathData, pub sources: Vec<usize> }
 pub fn regions(shapes: &[Shape]) -> Vec<Region>;            // all faces of the arrangement
 pub fn region_at(shapes: &[Shape], p: Point) -> Option<Region>;
 pub fn merge_regions(regions: &[&Region]) -> PathData;      // Shape Builder merge = union
+pub fn shape_builder(shapes: &[Shape]) -> (Vec<Region>, Vec<Shape>); // (regions, open-path pieces)
 ```
 
 Each result takes its key as follows:
@@ -58,6 +59,8 @@ pub fn interior_point(path: &PathData) -> Option<Point>;
 
 Unlike `regions`, which splits the filled areas of closed shapes, `live_paint` treats every path as an edge, open paths included. Three crossing lines enclose a triangle, a line across a rectangle splits it in two, and an area enclosed by paths becomes a face even when nothing fills it. Each face lists the inputs whose fill covers it; the list is empty for an area that is only enclosed by paths. Each edge is a piece of a path, split wherever another path meets it, and keeps the key of the front-most input it lies on.
 
+`shape_builder` gives the Shape Builder's regions. With closed paths only, they are the `regions`. Once an open path is among them, they are the `live_paint` faces, so a stroke-only line across a shape splits it and lines can enclose a region of their own. The second list holds the pieces of each path that has no closed subpath, keyed by its index, so the Shape Builder can delete them one by one. The caller closes any open path whose fill should count. Inputs with more than `SHAPE_BUILDER_MAX_SEGMENTS` segments fall back to the filled areas.
+
 ## Offset / stroke
 
 ```rust

crates/pathops/src/lib.rs

@@ -20,7 +20,7 @@ pub use edit::{
 };
 pub use offset::{Cap, Join, offset_path, outline_stroke, stroke_region};
 pub use pathfinder::{PathfinderOp, Region, Shape, merge_regions, pathfinder, region_at, regions};
-pub use planar::{interior_point, live_paint};
+pub use planar::{SHAPE_BUILDER_MAX_SEGMENTS, interior_point, live_paint, shape_builder};
 
 /// Errors from fallible operations.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]

crates/pathops/src/planar.rs

@@ -288,6 +288,32 @@ pub fn live_paint(shapes: &[Shape]) -> (Vec<Region>, Vec<Shape>) {
     build(shapes).unwrap_or_default()
 }
 
+/// Most segments the Shape Builder sweeps with open paths as edges: the planar map costs far more
+/// than the filled areas' arrangement, so past this only the filled areas count.
+pub const SHAPE_BUILDER_MAX_SEGMENTS: usize = 4096;
+
+/// Shape Builder regions of `shapes` (back → front), and the pieces of their open paths.
+///
+/// Closed paths bound regions with their filled areas, as in [`regions`](crate::regions). Open
+/// paths (the caller closes the ones whose fill should count) are cutting edges: a line across a
+/// shape splits it, lines around an area enclose a region nothing fills (empty `sources`), and each
+/// path with no closed subpath comes back cut wherever another path meets it, as pieces keyed by
+/// its index in `shapes`. With no open path, more than [`SHAPE_BUILDER_MAX_SEGMENTS`] segments or
+/// a map that can't be built, only the filled areas count and there are no pieces.
+pub fn shape_builder(shapes: &[Shape]) -> (Vec<Region>, Vec<Shape>) {
+    let has_open = shapes.iter().flat_map(|s| &s.path.subpaths).any(|sp| !sp.closed && sp.anchors.len() >= 2);
+    let segments: usize = shapes.iter().flat_map(|s| &s.path.subpaths).map(|sp| sp.segment_count()).sum();
+    if has_open && segments <= SHAPE_BUILDER_MAX_SEGMENTS {
+        let keyed: Vec<Shape> = shapes.iter().enumerate().map(|(i, s)| Shape::new(s.path.clone(), s.rule, i as u64)).collect();
+        let (faces, edges) = live_paint(&keyed);
+        if !faces.is_empty() || !edges.is_empty() {
+            let is_line = |i: u64| shapes.get(i as usize).is_some_and(|s| !s.path.subpaths.iter().any(|sp| sp.closed));
+            return (faces, edges.into_iter().filter(|e| is_line(e.key)).collect());
+        }
+    }
+    (crate::regions(shapes), Vec::new())
+}
+
 fn build(shapes: &[Shape]) -> Option<(Vec<Region>, Vec<Shape>)> {
     let mut inputs: Vec<(BezPath, usize)> = Vec::new();
     for (i, s) in shapes.iter().enumerate() {
@@ -736,6 +762,69 @@ mod tests {
         assert_eq!(edges.len(), 1);
     }
 
+    #[test]
+    fn shape_builder_lines_cut_regions() {
+        // A line across a rectangle: two regions, the line in three pieces keyed by its index.
+        let s = [rect(0.0, 0.0, 100.0, 50.0, 7), line((40.0, -20.0), (60.0, 70.0), 8)];
+        let (regions, lines) = shape_builder(&s);
+        assert_eq!(regions.len(), 2);
+        assert!(regions.iter().all(|r| r.sources == [0]));
+        assert_eq!(lines.len(), 3);
+        assert!(lines.iter().all(|l| l.key == 1 && !l.path.is_closed()));
+        // Lines alone enclose a region nothing fills.
+        let s = [line((0.0, 0.0), (100.0, 100.0), 0), line((100.0, 0.0), (0.0, 100.0), 0), line((-10.0, 80.0), (110.0, 80.0), 0)];
+        let (regions, lines) = shape_builder(&s);
+        assert_eq!(regions.len(), 1);
+        assert!(regions[0].sources.is_empty() && regions[0].top().is_none());
+        assert_eq!(lines.len(), 9);
+    }
+
+    #[test]
+    fn shape_builder_closed_only_or_degenerate_is_the_filled_arrangement() {
+        let s = [rect(0.0, 0.0, 100.0, 100.0, 0), rect(50.0, 0.0, 150.0, 100.0, 1)];
+        assert_eq!(shape_builder(&s), (crate::regions(&s), vec![]));
+        // A broken line can't be swept: what the filled areas give (nothing here, without a panic).
+        let s = [rect(0.0, 0.0, 100.0, 100.0, 0), line((0.0, 0.0), (f64::NAN, 1.0), 1)];
+        assert_eq!(shape_builder(&s), (crate::regions(&s), vec![]));
+        // Zero-length and doubled-back lines don't break it either.
+        let s = [
+            rect(0.0, 0.0, 100.0, 100.0, 0),
+            line((50.0, 50.0), (50.0, 50.0), 1),
+            line((0.0, 0.0), (100.0, 0.0), 2),
+            line((50.0, 0.0), (50.0, 100.0), 3),
+        ];
+        let (regions, _) = shape_builder(&s);
+        assert_eq!(regions.len(), 2);
+        assert!((regions.iter().map(area).sum::<f64>() - 10000.0).abs() < 1e-6);
+    }
+
+    #[test]
+    fn shape_builder_stays_quick_up_to_its_cap() {
+        // A wavy ring of nearly the most segments the map takes, crossed by a few lines.
+        let n = SHAPE_BUILDER_MAX_SEGMENTS - 8;
+        let ring: Vec<Point> = (0..n)
+            .map(|k| {
+                let t = k as f64 / n as f64 * std::f64::consts::TAU;
+                let r = 100.0 + 5.0 * (t * 200.0).sin();
+                Point::new(r * t.cos(), r * t.sin())
+            })
+            .collect();
+        let mut s = vec![Shape::new(PathData::single(SubPath::polyline(&ring, true)), FillRule::NonZero, 0)];
+        for k in 0..4 {
+            let y = -60.0 + 40.0 * f64::from(k);
+            s.push(line((-150.0, y), (150.0, y + 7.0), 1));
+        }
+        let started = std::time::Instant::now();
+        let (regions, lines) = shape_builder(&s);
+        assert!(regions.len() >= 5, "the ring cut in five bands at least (the waves make pockets)");
+        assert!(lines.len() >= 12, "{}", lines.len());
+        assert!(started.elapsed().as_secs_f64() < 5.0, "{:?}", started.elapsed());
+        // Past the cap, only the filled areas count.
+        s.push(line((0.0, 0.0), (1.0, 1.0), 2));
+        s[0].path.subpaths[0].anchors.extend((0..16).map(|k| vectorcraft_geom::Anchor::corner(Point::new(100.0, f64::from(k)))));
+        assert!(shape_builder(&s).1.is_empty());
+    }
+
     fn arb_segment() -> impl Strategy<Value = Shape> {
         let c = || (0..10i32).prop_map(|v| f64::from(v) * 10.0);
         prop_oneof![

crates/pdf/Cargo.toml

@@ -20,6 +20,8 @@ kurbo = { workspace = true }
 thiserror = { workspace = true }
 flate2 = { workspace = true }
 image = { workspace = true }
+# CMYK JPEGs (the image crate writes RGB and grey ones only).
+jpeg-encoder = { workspace = true }
 krilla = { workspace = true }
 hayro-syntax = "0.7.2"
 hayro-interpret = { version = "0.7.0", default-features = false, features = ["embed-fonts", "embed-cmaps"] }

crates/pdf/src/export.rs

@@ -1470,8 +1470,8 @@ impl Exporter<'_> {
     }
 
     /// Image `key` placed `size` points wide and high, resampled and compressed as the Compression
-    /// settings say ([`crate::images::recode`]); cached by key (and size when images are
-    /// resampled).
+    /// settings say ([`crate::images::recode`], [`crate::images::recode_cmyk`] for CMYK images);
+    /// cached by key (and size when images are resampled).
     fn load_image(&mut self, key: &str, size: (f64, f64)) -> Option<Image> {
         let c = self.compression;
         let sized = [c.color.downsample, c.gray.downsample, c.mono.downsample].iter().any(|d| *d != crate::Downsample::None);
@@ -1483,7 +1483,11 @@ impl Exporter<'_> {
         let doc = self.doc;
         let out = self.out.clone();
         let img = doc.images.get(key).and_then(|blob| {
-            let r = crate::images::recode(&blob.bytes, size, c, interpolate, out.pixels());
+            let r = if blob.is_cmyk() {
+                crate::images::recode_cmyk(blob, size, c, interpolate, out.cmyk_pixels())
+            } else {
+                crate::images::recode(&blob.bytes, size, c, interpolate, out.pixels())
+            };
             if let Some(w) = r.warning {
                 self.warn(w);
             }

crates/pdf/src/images.rs

@@ -6,16 +6,23 @@
 //! monochrome (greyscale that is only black and white). An image already as asked (not resampled,
 //! a JPEG kept as JPEG or another kept lossless) is embedded as it is; the others are decoded,
 //! resampled and encoded again. JPEG needs opaque pixels: images with transparency stay lossless.
+//!
+//! CMYK images ([`ImageBlob::cmyk`]) stay CMYK: a CMYK JPEG already as asked is embedded as it is
+//! when its numbers are kept; the others' ink amounts are resampled, converted when the Output
+//! settings convert CMYK colours ([`CmykPixels`]) and compressed again. CMYK JPEGs hold Adobe's
+//! inverted samples, which the PDF writer's Decode array undoes.
 
 use std::io::Cursor;
 use std::sync::Arc;
 
-use image::buffer::ConvertBuffer;
 use image::imageops::FilterType;
-use image::{DynamicImage, ExtendedColorType, ImageDecoder, ImageFormat, ImageReader, RgbaImage};
+use image::{DynamicImage, ExtendedColorType, ImageDecoder, ImageFormat, ImageReader};
 use krilla::image::{BitsPerComponent, CustomImage, Image, ImageColorspace};
 
-use crate::output::Pixels;
+use vectorcraft_doc::ImageBlob;
+use vectorcraft_doc::cmyk::jpeg_components;
+
+use crate::output::{CmykPixels, Pixels};
 use crate::{CompressionSettings, Downsample, ImageCodec, JpegQuality, MonoCodec};
 
 /// Raw 8-bit pixels: colour samples (RGB, grey or CMYK) and an optional alpha channel.
@@ -54,23 +61,16 @@ impl CustomImage for Raw {
     }
 }
 
-/// A `width` × `height` image of straight (not premultiplied) RGBA pixels, written as RGB, or as
-/// grey when every pixel is grey, with an alpha channel only when some pixel isn't opaque.
-/// `interpolate` asks viewers to smooth it when enlarged (PDF/A forbids it). `None` when `rgba`
-/// doesn't hold that many pixels.
-pub(crate) fn from_rgba(rgba: &[u8], width: u32, height: u32, interpolate: bool) -> Option<Image> {
-    from_rgba_as(rgba, width, height, interpolate, None)
-}
-
-/// [`from_rgba`], colour pixels written as CMYK when `pixels` converts to CMYK (grey ones stay
-/// grey).
-fn from_rgba_as(rgba: &[u8], width: u32, height: u32, interpolate: bool, pixels: Option<&Pixels>) -> Option<Image> {
+/// A `width` × `height` image of straight (not premultiplied) RGBA pixels, written as RGB (as
+/// CMYK when `pixels` converts to CMYK), or as grey when every pixel is grey, with an alpha
+/// channel only when some pixel isn't opaque. `interpolate` asks viewers to smooth it when
+/// enlarged (PDF/A forbids it). `None` when `rgba` doesn't hold that many pixels.
+fn from_rgba(rgba: &[u8], width: u32, height: u32, interpolate: bool, pixels: Option<&Pixels>) -> Option<Image> {
     let px = rgba.as_chunks::<4>().0;
     if px.len() as u64 != width as u64 * height as u64 || px.is_empty() {
         return None;
     }
-    let luma = px.iter().all(|p| p[0] == p[1] && p[1] == p[2]);
-    let (color, space) = if luma {
+    let (color, space) = if neutral(rgba) {
         (px.iter().map(|p| p[0]).collect(), ImageColorspace::Luma)
     } else if let Some(cmyk) = pixels.and_then(|p| p.cmyk(rgba)) {
         (cmyk, ImageColorspace::Cmyk)
@@ -81,12 +81,22 @@ fn from_rgba_as(rgba: &[u8], width: u32, height: u32, interpolate: bool, pixels:
     Image::from_custom(Raw { color: Arc::new(color), alpha, width, height, space }, interpolate).ok()
 }
 
+/// Are all of the RGBA pixels `rgba` grey?
+fn neutral(rgba: &[u8]) -> bool {
+    rgba.as_chunks::<4>().0.iter().all(|p| p[0] == p[1] && p[1] == p[2])
+}
+
+/// Opaque colour `samples` (grey, RGB, or CMYK ink amounts, as `space` says) written losslessly.
+fn lossless(samples: Vec<u8>, space: ImageColorspace, width: u32, height: u32, interpolate: bool) -> Option<Image> {
+    Image::from_custom(Raw { color: Arc::new(samples), alpha: None, width, height, space }, interpolate).ok()
+}
+
 /// [`from_rgba`] of pixels converted by `pixels` (when given).
 pub(crate) fn from_rgba_in(mut rgba: Vec<u8>, width: u32, height: u32, interpolate: bool, pixels: Option<&Pixels>) -> Option<Image> {
     if let Some(p) = pixels {
         p.rgb_in_place(&mut rgba);
     }
-    from_rgba_as(&rgba, width, height, interpolate, pixels)
+    from_rgba(&rgba, width, height, interpolate, pixels)
 }
 
 /// The kinds of images the Compression section has settings for.
@@ -118,7 +128,8 @@ struct Rule {
 }
 
 const UNCOMPRESSED: &str = "uncompressed images are not written: images are compressed with ZIP";
-const CMYK_ZIP: &str = "images converted to CMYK are compressed with ZIP, not JPEG";
+const CMYK_KEPT: &str = "a CMYK image couldn't be decoded: it is written as it is, not resampled or converted";
+const CMYK_RGB: &str = "a CMYK image couldn't be decoded in CMYK: it is written in RGB";
 
 /// JPEG quality (1–100) of a quality setting.
 fn quality(q: JpegQuality) -> u8 {
@@ -166,6 +177,48 @@ fn bilevel(img: &DynamicImage) -> bool {
     img.to_luma_alpha8().pixels().all(|p| p[0] == 0 || p[0] == 255)
 }
 
+/// The size `r` gives an image of `w` × `h` pixels placed `size` points wide and high: a side
+/// whose resolution is above the threshold goes down to the target resolution.
+fn sized(r: &Rule, (w, h): (u32, u32), size: (f64, f64)) -> (u32, u32) {
+    let ppi = |px: u32, pt: f64| px as f64 * 72.0 / pt.abs();
+    let (px, py) = (ppi(w, size.0), ppi(h, size.1));
+    let resample = r.downsample != Downsample::None && [px, py].iter().any(|p| p.is_finite() && *p > r.above);
+    let side = |n: u32, p: f64| if resample && p.is_finite() && p > r.ppi { ((n as f64 * r.ppi / p).round() as u32).clamp(1, n) } else { n };
+    (side(w, px), side(h, py))
+}
+
+/// Is an image of `dims` pixels placed `size` points already as `r` asks: not resampled, and
+/// lossless or (`jpeg`) a JPEG kept as JPEG?
+fn kept(r: &Rule, dims: (u32, u32), size: (f64, f64), jpeg: bool) -> bool {
+    sized(r, dims, size) == dims
+        && match r.codec {
+            Codec::Auto(_) => true,
+            Codec::Zip => !jpeg,
+            Codec::Jpeg(_) => jpeg,
+        }
+}
+
+/// The JPEG quality `r` compresses an image with (`jpeg`: it is a JPEG); `None`: lossless.
+fn jpeg_quality(r: &Rule, jpeg: bool) -> Option<u8> {
+    match r.codec {
+        Codec::Jpeg(q) => Some(q),
+        Codec::Auto(q) if jpeg => Some(q),
+        _ => None,
+    }
+}
+
+/// `img` resampled to `w` × `h` pixels as `r` says.
+fn resample(img: DynamicImage, r: &Rule, (w, h): (u32, u32)) -> DynamicImage {
+    if (w, h) == (img.width(), img.height()) {
+        return img;
+    }
+    match r.downsample {
+        Downsample::Average => img.thumbnail_exact(w, h),
+        Downsample::Subsample => img.resize_exact(w, h, FilterType::Nearest),
+        Downsample::Bicubic | Downsample::None => img.resize_exact(w, h, FilterType::CatmullRom),
+    }
+}
+
 /// Encoded image `bytes` placed `size` points wide and high, as the Compression settings `c` ask:
 /// resampled when its resolution is above the threshold, compressed with ZIP or JPEG, its colours
 /// converted by `convert` (colour images). `interpolate` lets viewers smooth it. An image that
@@ -175,30 +228,13 @@ pub(crate) fn recode(bytes: &[u8], size: (f64, f64), c: &CompressionSettings, in
     let Ok(reader) = ImageReader::new(Cursor::new(bytes)).with_guessed_format() else { return keep };
     let jpeg = reader.format() == Some(ImageFormat::Jpeg);
     let Ok(decoder) = reader.into_decoder() else { return keep };
-    let (w, h) = decoder.dimensions();
-    // Resolution along each side as placed; above the threshold, a side goes down to the target.
-    let ppi = |px: u32, pt: f64| px as f64 * 72.0 / pt.abs();
-    let (px, py) = (ppi(w, size.0), ppi(h, size.1));
-    let sized = |r: &Rule| {
-        let resample = r.downsample != Downsample::None && [px, py].iter().any(|p| p.is_finite() && *p > r.above);
-        let side = |n: u32, p: f64| if resample && p.is_finite() && p > r.ppi { ((n as f64 * r.ppi / p).round() as u32).clamp(1, n) } else { n };
-        (side(w, px), side(h, py))
-    };
-    // Already as asked: not resampled, and lossless or a JPEG kept as JPEG.
-    let kept = |r: &Rule| {
-        sized(r) == (w, h)
-            && match r.codec {
-                Codec::Auto(_) => true,
-                Codec::Zip => !jpeg,
-                Codec::Jpeg(_) => jpeg,
-            }
-    };
+    let dims = decoder.dimensions();
     use ExtendedColorType as T;
     let grey = matches!(decoder.original_color_type(), T::L1 | T::La1 | T::L2 | T::La2 | T::L4 | T::La4 | T::L8 | T::La8 | T::L16 | T::La16);
     let (kind, pixels) = if grey {
         // Only the pixels tell monochrome images from greyscale ones: decoded unless both keep it.
         let (g, m) = (rule(c, Kind::Gray), rule(c, Kind::Mono));
-        if kept(&g) && kept(&m) && g.instead == m.instead {
+        if kept(&g, dims, size, jpeg) && kept(&m, dims, size, jpeg) && g.instead == m.instead {
             return Recoded { image: None, warning: g.instead };
         }
         let Ok(img) = DynamicImage::from_decoder(decoder) else { return keep };
@@ -208,21 +244,11 @@ pub(crate) fn recode(bytes: &[u8], size: (f64, f64), c: &CompressionSettings, in
     };
     let rule = rule(c, kind);
     let convert = convert.filter(|_| kind == Kind::Color);
-    if kept(&rule) && convert.is_none() {
+    if kept(&rule, dims, size, jpeg) && convert.is_none() {
         return Recoded { image: None, warning: rule.instead };
     }
     let Some(img) = pixels.or_else(|| image::load_from_memory(bytes).ok()) else { return keep };
-    let (nw, nh) = sized(&rule);
-    let img = if (nw, nh) == (w, h) {
-        img
-    } else {
-        match rule.downsample {
-            Downsample::Average => img.thumbnail_exact(nw, nh),
-            Downsample::Subsample => img.resize_exact(nw, nh, FilterType::Nearest),
-            Downsample::Bicubic | Downsample::None => img.resize_exact(nw, nh, FilterType::CatmullRom),
-        }
-    };
-    let mut rgba = img.to_rgba8();
+    let mut rgba = resample(img, &rule, sized(&rule, dims, size)).into_rgba8();
     if kind == Kind::Mono {
         // Resampling greys the edges: back to black and white.
         for p in rgba.pixels_mut() {
@@ -230,33 +256,70 @@ pub(crate) fn recode(bytes: &[u8], size: (f64, f64), c: &CompressionSettings, in
             (p[0], p[1], p[2]) = (v, v, v);
         }
     }
-    let quality = match rule.codec {
-        Codec::Jpeg(q) => Some(q),
-        Codec::Auto(q) if jpeg => Some(q),
-        _ => None,
-    };
-    // CMYK images are written losslessly (the PDF writer's CMYK JPEGs need the reader's
-    // conventions).
-    let cmyk = convert.is_some_and(|p| p.is_cmyk());
+    if let Some(p) = convert {
+        p.rgb_in_place(&mut rgba);
+    }
     let (width, height) = rgba.dimensions();
     let opaque = rgba.pixels().all(|p| p[3] == 255);
-    let image = match quality.filter(|_| opaque && !cmyk) {
-        Some(q) => {
-            if let Some(p) = convert {
-                p.rgb_in_place(&mut rgba);
-            }
-            to_jpeg(&rgba, kind != Kind::Color, q, interpolate).or_else(|| from_rgba(rgba.as_raw(), width, height, interpolate))
-        }
-        None => from_rgba_in(rgba.into_raw(), width, height, interpolate, convert),
-    };
-    let warning = rule.instead.or((cmyk && quality.is_some() && opaque).then_some(CMYK_ZIP));
-    Recoded { image, warning }
+    let jpeg = jpeg_quality(&rule, jpeg).filter(|_| opaque).and_then(|q| {
+        // Grey pixels stay grey; colour ones go to CMYK when the output converts to CMYK.
+        let grey = kind != Kind::Color || neutral(&rgba);
+        let (samples, space) = match convert.filter(|_| !grey).and_then(|p| p.cmyk(&rgba)) {
+            Some(cmyk) => (cmyk, ImageColorspace::Cmyk),
+            None if grey => (rgba.pixels().map(|p| p[0]).collect(), ImageColorspace::Luma),
+            None => (rgba.pixels().flat_map(|p| [p[0], p[1], p[2]]).collect(), ImageColorspace::Rgb),
+        };
+        to_jpeg(&samples, space, width, height, q, interpolate)
+    });
+    let image = jpeg.or_else(|| from_rgba(rgba.as_raw(), width, height, interpolate, convert));
+    Recoded { image, warning: rule.instead }
 }
 
-/// Opaque `rgba` as a JPEG image at `quality` (a greyscale JPEG with `grey`).
-fn to_jpeg(rgba: &RgbaImage, grey: bool, quality: u8, interpolate: bool) -> Option<Image> {
-    let img = if grey { DynamicImage::ImageLuma8(rgba.convert()) } else { DynamicImage::ImageRgb8(rgba.convert()) };
+/// [`recode`] of CMYK image `blob` ([`ImageBlob::cmyk`]): a JPEG already as asked is kept as it
+/// is when its numbers are (`convert` is `None`); otherwise its ink amounts are resampled,
+/// converted by `convert` and compressed again.
+pub(crate) fn recode_cmyk(blob: &ImageBlob, size: (f64, f64), c: &CompressionSettings, interpolate: bool, convert: Option<&CmykPixels>) -> Recoded {
+    let rule = rule(c, Kind::Color);
+    let jpeg = jpeg_components(&blob.bytes).is_some();
+    if jpeg && convert.is_none() {
+        let dims = ImageReader::new(Cursor::new(blob.bytes.as_slice())).with_guessed_format().ok().and_then(|r| r.into_dimensions().ok());
+        if dims.is_some_and(|d| kept(&rule, d, size, true)) {
+            return Recoded { image: None, warning: rule.instead };
+        }
+    }
+    let Some(inks) = blob.cmyk() else {
+        return Recoded { image: None, warning: Some(if jpeg { CMYK_KEPT } else { CMYK_RGB }) };
+    };
+    let dims = (inks.width, inks.height);
+    let (width, height) = sized(&rule, dims, size);
+    // The four inks resample as the four channels of an RGBA image do.
+    let inks = match image::RgbaImage::from_raw(inks.width, inks.height, inks.data) {
+        Some(img) => resample(DynamicImage::ImageRgba8(img), &rule, (width, height)).into_rgba8().into_raw(),
+        None => return Recoded { image: None, warning: Some(CMYK_RGB) },
+    };
+    let (samples, space) = match convert {
+        Some(p) => p.convert(&inks),
+        None => (inks, ImageColorspace::Cmyk),
+    };
+    let image = jpeg_quality(&rule, jpeg).and_then(|q| to_jpeg(&samples, space, width, height, q, interpolate));
+    let image = image.or_else(|| lossless(samples, space, width, height, interpolate));
+    Recoded { image, warning: rule.instead }
+}
+
+/// Opaque colour `samples` (grey, RGB, or CMYK ink amounts, as `space` says) as a JPEG at
+/// `quality`. CMYK JPEGs hold Adobe's inverted samples, which the PDF writer's Decode array
+/// undoes.
+fn to_jpeg(samples: &[u8], space: ImageColorspace, width: u32, height: u32, quality: u8, interpolate: bool) -> Option<Image> {
     let mut out = Vec::new();
-    image::codecs::jpeg::JpegEncoder::new_with_quality(&mut out, quality).encode_image(&img).ok()?;
+    match space {
+        ImageColorspace::Cmyk => {
+            let (w, h) = (u16::try_from(width).ok()?, u16::try_from(height).ok()?);
+            jpeg_encoder::Encoder::new(&mut out, quality).encode(samples, w, h, jpeg_encoder::ColorType::Cmyk).ok()?;
+        }
+        ImageColorspace::Rgb | ImageColorspace::Luma => {
+            let t = if space == ImageColorspace::Rgb { ExtendedColorType::Rgb8 } else { ExtendedColorType::L8 };
+            image::codecs::jpeg::JpegEncoder::new_with_quality(&mut out, quality).encode(samples, width, height, t).ok()?;
+        }
+    }
     Image::from_jpeg(out.into(), interpolate).ok()
 }

crates/pdf/src/import.rs

@@ -1,6 +1,6 @@
 //! PDF → Document (hayro-interpret device that builds a VectorCraft node tree).
 
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::sync::{Arc, Mutex};
 
 use hayro_interpret::font::Glyph;
@@ -11,7 +11,7 @@ use hayro_interpret::{
     MaskType, PathDrawMode, SoftMask, StrokeProps, interpret_page,
 };
 use hayro_syntax::object::Name;
-use kurbo::{Affine, BezPath, Rect, Shape};
+use kurbo::{Affine, BezPath, PathEl, Rect, Shape};
 use vectorcraft_color::{BlendMode, Color, Paint, Swatch};
 use vectorcraft_doc::{
     Appearance, AppearanceItem, Artboard, ColorMode, Dash, Document, FillLayer, ImageBlob, ImageObject, Knockout, LayerColor, LineCap, LineJoin,
@@ -21,7 +21,7 @@ use vectorcraft_geom::{FillRule, PathData};
 
 use crate::import_color::{Colors, Native};
 use crate::import_mask::{MaskSpec, contains, is_rectangle, luminance, mask_spec, white_cover};
-use crate::import_scan::{Ocgs, Scan, all_on, hides_forms, scan_page};
+use crate::import_scan::{MAX_NESTING, Ocgs, Scan, all_on, hides_forms, scan_page};
 use crate::import_shading::{clipped, extend_clip, fold_stop_opacity, mesh_shading, shading_gradient};
 use crate::import_text::{Families, Look, Placement, TextLine, Upright};
 use crate::{CropTo, ImportOptions, ImportReport, PdfError, TextAs};
@@ -46,6 +46,60 @@ enum Slot {
     Group(usize),
 }
 
+/// What each group's layer holds, in paint order: its sublayers (their groups) and, where its
+/// own group is listed, its art.
+type Nesting = HashMap<usize, Vec<usize>>;
+
+/// Group `g` paints (its first art): note where its art goes in its layer, and where that layer
+/// goes when it is new: in its parent's layer (placed the same way) or, for a top-level group, in
+/// `slots`.
+fn place_group(g: usize, ocgs: &Ocgs, slots: &mut Vec<Slot>, nesting: &mut Nesting) {
+    let placed = nesting.contains_key(&g);
+    nesting.entry(g).or_default().push(g);
+    if placed {
+        return;
+    }
+    let mut child = g;
+    // Each parent is placed before its sublayers, so the chain ends (within the nesting depth).
+    for _ in 0..=MAX_NESTING {
+        let Some(parent) = ocgs.list.get(child).and_then(|o| o.parent) else { break };
+        let placed = nesting.contains_key(&parent);
+        nesting.entry(parent).or_default().push(child);
+        if placed {
+            return;
+        }
+        child = parent;
+    }
+    slots.push(Slot::Group(child));
+}
+
+/// The layer of group `g`, in `color`: its art and sublayers. `None` for a group that isn't read.
+fn group_layer(
+    b: &mut Builder<'_>,
+    g: usize,
+    ocgs: &Ocgs,
+    nesting: &Nesting,
+    art: &mut HashMap<usize, Vec<Arc<Node>>>,
+    color: LayerColor,
+) -> Option<Node> {
+    let ocg = ocgs.list.get(g)?;
+    let mut l = Node::layer(b.id(), &ocg.name, color);
+    (l.visible, l.locked) = (ocg.on, ocg.locked);
+    let mut children = vec![];
+    for &c in nesting.get(&g).into_iter().flatten() {
+        if c == g {
+            children.extend(art.remove(&g).unwrap_or_default());
+        } else if let Some(sub) = group_layer(b, c, ocgs, nesting, art, color) {
+            children.push(Arc::new(sub));
+        }
+    }
+    if let NodeKind::Layer { children: c, printable, .. } = &mut l.kind {
+        *c = children;
+        *printable = ocg.print;
+    }
+    Some(l)
+}
+
 /// Import a PDF, returning the document plus warnings about content that was approximated or skipped.
 pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportReport, PdfError> {
     let original = crate::pages::open(bytes, opts.password.as_deref())?;
@@ -54,7 +108,7 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
     let route = opts.layers && !ocgs.list.is_empty();
     // Content that is off imports as hidden layers: an update of the file turns every group on
     // (unless a form is hidden by its own group: its art couldn't be told apart).
-    let hide = route && ocgs.any_off();
+    let hide = route && ocgs.skips_any();
     let turned_on = (hide && !picked.iter().filter_map(|&n| original.pages().get(n)).any(|p| hides_forms(p, &mut ocgs)))
         .then(|| all_on(bytes, &original))
         .flatten()
@@ -100,6 +154,7 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
     let mut placeholder = true;
     let mut slots: Vec<Slot> = vec![];
     let mut group_art: HashMap<usize, Vec<Arc<Node>>> = HashMap::new();
+    let mut nesting = Nesting::new();
     for (i, &number) in picked.iter().enumerate() {
         let Some(page) = pages.get(number) else { continue };
         // The chosen box sits at (x, 0); the page draws round it.
@@ -158,7 +213,7 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
                 None => slots.push(page_layer(&mut b, art)),
                 Some(g) => {
                     let into = group_art.entry(g).or_insert_with(|| {
-                        slots.push(Slot::Group(g));
+                        place_group(g, &ocgs, &mut slots, &mut nesting);
                         vec![]
                     });
                     into.extend(art);
@@ -172,16 +227,11 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
     for (n, slot) in slots.into_iter().enumerate() {
         let layer = match slot {
             Slot::Page(l) => *l,
-            Slot::Group(g) => {
-                let Some(ocg) = ocgs.list.get(g) else { continue };
-                let mut l = Node::layer(b.id(), &ocg.name, LayerColor::Preset((n % 27) as u8));
-                (l.visible, l.locked) = (ocg.on, ocg.locked);
-                if let NodeKind::Layer { children, printable, .. } = &mut l.kind {
-                    *children = group_art.remove(&g).unwrap_or_default();
-                    *printable = ocg.print;
-                }
-                l
-            }
+            // Sublayers take their top-level layer's colour.
+            Slot::Group(g) => match group_layer(&mut b, g, &ocgs, &nesting, &mut group_art, LayerColor::Preset((n % 27) as u8)) {
+                Some(l) => l,
+                None => continue,
+            },
         };
         doc.layers.push(Arc::new(layer));
     }
@@ -462,6 +512,8 @@ struct Builder<'p> {
     text_as: TextAs,
     images: HashMap<String, ImageBlob>,
     image_keys: HashMap<u128, (String, u32, u32)>,
+    /// The images kept with their CMYK samples ([`crate::import_image`]).
+    cmyk_keys: HashSet<u128>,
     warnings: Vec<String>,
     /// Fonts by cache key → base font name (from [`scan_page`]).
     fonts: HashMap<u128, String>,
@@ -495,6 +547,8 @@ struct Builder<'p> {
     /// A transparency group was just pushed: a form's (whose flags come next) or an image's.
     pending: bool,
     nested: u32,
+    /// The last filled path: its node and its outline (a stroke of the same outline joins it).
+    last_fill: Option<(NodeId, BezPath)>,
 }
 
 fn blend(b: hayro_interpret::BlendMode) -> BlendMode {
@@ -526,6 +580,29 @@ fn fill_rule(r: hayro_interpret::FillRule) -> FillRule {
     }
 }
 
+/// `p` with every subpath closed: how a fill reads it.
+fn closed_subpaths(p: &BezPath) -> BezPath {
+    let mut out = BezPath::new();
+    let mut open = false;
+    for el in p.elements() {
+        if open && matches!(el, PathEl::MoveTo(_)) {
+            out.push(PathEl::ClosePath);
+        }
+        out.push(*el);
+        open = !matches!(el, PathEl::ClosePath);
+    }
+    if open {
+        out.push(PathEl::ClosePath);
+    }
+    out
+}
+
+/// Do a fill of `fill` and a stroke of `stroke` paint one object's outline? Applications write the
+/// fill without closing the path (filling closes it) and the stroke closed.
+fn same_outline(fill: &BezPath, stroke: &BezPath) -> bool {
+    fill.elements() == stroke.elements() || closed_subpaths(fill).elements() == closed_subpaths(stroke).elements()
+}
+
 fn mean_scale(a: Affine) -> f64 {
     a.determinant().abs().sqrt()
 }
@@ -582,6 +659,7 @@ impl<'p> Builder<'p> {
             text_as,
             images: HashMap::new(),
             image_keys: HashMap::new(),
+            cmyk_keys: HashSet::new(),
             warnings: vec![],
             fonts: HashMap::new(),
             font_names: HashMap::new(),
@@ -603,6 +681,7 @@ impl<'p> Builder<'p> {
             marked: vec![],
             pending: false,
             nested: 0,
+            last_fill: None,
         }
     }
 
@@ -653,10 +732,15 @@ impl<'p> Builder<'p> {
         let children = self.close_frames();
         let groups = std::mem::take(&mut self.root_groups);
         let mut parts: Vec<(Option<usize>, Vec<Arc<Node>>)> = vec![];
+        // Thousands of groups: find each one's part by index.
+        let mut at: HashMap<Option<usize>, usize> = HashMap::new();
         for (n, g) in children.into_iter().zip(groups.into_iter().chain(std::iter::repeat(None))) {
-            match parts.iter_mut().find(|(k, _)| *k == g) {
-                Some((_, v)) => v.push(n),
-                None => parts.push((g, vec![n])),
+            let i = *at.entry(g).or_insert_with(|| {
+                parts.push((g, vec![]));
+                parts.len() - 1
+            });
+            if let Some((_, v)) = parts.get_mut(i) {
+                v.push(n);
             }
         }
         parts
@@ -1216,24 +1300,35 @@ impl<'a> Device<'a> for Builder<'_> {
                 if let NodeKind::Path { rule: r, .. } = &mut n.kind {
                     *r = fill_rule(*rule);
                 }
+                self.last_fill = Some((n.id, bp));
                 let n = wrap(self, n);
                 self.push_node(n);
             }
             PathDrawMode::Stroke(props) => {
                 let st = stroke_layer(paint, opacity, props, mean_scale(transform));
-                // Fill-then-stroke of the same path (the `B` operator) becomes one object.
+                // Fill-then-stroke of the same path (the `B` operator, or a fill and a stroke of
+                // the outline as Illustrator writes an object) becomes one object: a path with a
+                // fill and a live stroke.
                 let blend = self.blend;
+                let fill = self.last_fill.take();
                 let last = match self.mask {
                     Some(_) => self.masked.last_mut(),
                     None => self.stack.last_mut().and_then(|f| f.children.last_mut()),
                 };
                 if band.is_none()
                     && let Some(last) = last
+                    && let Some((id, outline)) = fill
+                    && last.id == id
                     && last.blend == blend
-                    && last.path_data() == Some(&pd)
                     && last.appearance.stroke().is_none()
+                    && same_outline(&outline, &bp)
                 {
-                    Arc::make_mut(last).appearance.items.push(AppearanceItem::Stroke(st));
+                    let last = Arc::make_mut(last);
+                    // The stroke's outline: closing it changes the stroke, not the fill.
+                    if let Some(p) = last.path_data_mut() {
+                        *p = pd;
+                    }
+                    last.appearance.items.push(AppearanceItem::Stroke(st));
                     return;
                 }
                 let n = Node::path(self.id(), pd, Appearance { items: vec![AppearanceItem::Stroke(st)], ..Default::default() });
@@ -1335,8 +1430,23 @@ impl<'a> Device<'a> for Builder<'_> {
         match image {
             Image::Raster(r) => {
                 let key = hayro_interpret::CacheKey::cache_key(&r);
-                // JPEG passthrough for plain DeviceRGB/DeviceGray DCT images.
                 let st = r.stream();
+                let (w, h) = (r.width(), r.height());
+                // CMYK images keep their samples (read once per image).
+                let known = self.cmyk_keys.contains(&key);
+                let cmyk = if known {
+                    None
+                } else {
+                    crate::import_image::cmyk(st, w, h).unwrap_or_else(|why| {
+                        self.warn(why);
+                        None
+                    })
+                };
+                if known || cmyk.is_some() {
+                    self.cmyk_keys.insert(key);
+                    return self.add_image(key, || cmyk.map(|blob| (blob, w, h)), transform);
+                }
+                // JPEG passthrough for plain DeviceRGB/DeviceGray DCT images.
                 let dict = st.dict();
                 let filters = st.filters();
                 let cs_ok = dict.get::<Name<'_>>(b"ColorSpace").is_some_and(|n| matches!(n.as_ref(), b"DeviceRGB" | b"DeviceGray"));
@@ -1347,7 +1457,6 @@ impl<'a> Device<'a> for Builder<'_> {
                     && !dict.contains_key(b"Mask")
                     && !dict.contains_key(b"Decode");
                 if jpeg {
-                    let (w, h) = (r.width(), r.height());
                     let bytes = st.raw_data().to_vec();
                     self.add_image(key, || Some((ImageBlob::new("image/jpeg", bytes), w, h)), transform);
                     return;

crates/pdf/src/import_image.rs

@@ -0,0 +1,93 @@
+//! CMYK images keep their samples, as CMYK colours do: DeviceCMYK images and ICC-based ones with
+//! four components. A JPEG whose Decode array inverts its samples (Adobe's CMYK JPEGs, the
+//! convention JPEG readers and the PDF writer take a CMYK JPEG to follow) is kept as it is; any
+//! other is decoded, its Decode array applied, and stored as a CMYK TIFF
+//! ([`ImageBlob::cmyk_tiff`]). Every other image is read as RGB by the interpreter.
+
+use hayro_syntax::Filter;
+use hayro_syntax::object::stream::ImageDecodeParams;
+use hayro_syntax::object::{Array, Dict, Name, Stream};
+use vectorcraft_doc::ImageBlob;
+use vectorcraft_doc::cmyk::{Inks, MAX_CMYK_PIXELS, jpeg_components};
+
+/// A CMYK image read as RGB: why.
+pub(crate) const MASKED: &str = "CMYK images with a mask were imported in RGB";
+pub(crate) const UNREAD: &str = "CMYK images whose samples couldn't be read in CMYK were imported in RGB";
+
+/// The Decode array of a JPEG kept as it is.
+const INVERTED: [(f32, f32); 4] = [(1.0, 0.0); 4];
+
+/// `key`, or its inline-image abbreviation `short` when `d` doesn't have it.
+fn key<'k>(d: &Dict<'_>, key: &'k [u8], short: &'k [u8]) -> &'k [u8] {
+    if d.contains_key(key) { key } else { short }
+}
+
+/// Are the image's colours CMYK (DeviceCMYK, CalCMYK, or ICC-based with four components)?
+fn cmyk_space(d: &Dict<'_>) -> bool {
+    let cs = key(d, b"ColorSpace", b"CS");
+    if let Some(n) = d.get::<Name<'_>>(cs) {
+        return matches!(n.as_ref(), b"DeviceCMYK" | b"CMYK");
+    }
+    let Some(a) = d.get::<Array<'_>>(cs) else { return false };
+    let mut it = a.flex_iter();
+    match it.next::<Name<'_>>() {
+        Some(n) if n.as_ref() == b"CalCMYK" => true,
+        Some(n) if n.as_ref() == b"ICCBased" => it.next::<Stream<'_>>().and_then(|s| s.dict().get::<u8>(b"N")) == Some(4),
+        _ => false,
+    }
+}
+
+/// Each component's Decode range (`[0 1]` each when the array is missing or malformed).
+fn decode_ranges(d: &Dict<'_>) -> [(f32, f32); 4] {
+    let mut out = [(0.0, 1.0); 4];
+    let Some(a) = d.get::<Array<'_>>(key(d, b"Decode", b"D")) else { return out };
+    let v: Vec<f32> = a.iter::<f32>().collect();
+    if v.len() == 8 && v.iter().all(|x| x.is_finite()) {
+        for (o, p) in out.iter_mut().zip(v.as_chunks::<2>().0) {
+            *o = (p[0], p[1]);
+        }
+    }
+    out
+}
+
+/// The image `st` (`width` × `height` pixels) in CMYK: `Ok(None)` when it isn't a CMYK image,
+/// `Err` (a warning) when it is one that is read as RGB.
+pub(crate) fn cmyk(st: &Stream<'_>, width: u32, height: u32) -> Result<Option<ImageBlob>, &'static str> {
+    let d = st.dict();
+    if !cmyk_space(d) {
+        return Ok(None);
+    }
+    if d.contains_key(b"SMask") || d.contains_key(b"Mask") {
+        return Err(MASKED);
+    }
+    let ranges = decode_ranges(d);
+    let filters = st.filters();
+    if ranges == INVERTED && matches!(filters.as_slice(), [Filter::DctDecode]) {
+        let raw = st.raw_data();
+        if jpeg_components(&raw) == Some(4) {
+            return Ok(Some(ImageBlob::new("image/jpeg", raw.into_owned())));
+        }
+    }
+    let bpc = d.get::<u8>(key(d, b"BitsPerComponent", b"BPC")).unwrap_or(8);
+    if !matches!(bpc, 8 | 16) {
+        return Err(UNREAD);
+    }
+    let n = width as u64 * height as u64;
+    if n == 0 || n > MAX_CMYK_PIXELS {
+        return Err(UNREAD);
+    }
+    let size = usize::from(bpc / 8);
+    let params = ImageDecodeParams { is_indexed: false, bpc: Some(bpc), num_components: Some(4), target_dimension: None, width, height };
+    let Ok(decoded) = st.decoded_image(&params) else { return Err(UNREAD) };
+    let Some(raw) = decoded.data.get(..n as usize * 4 * size) else { return Err(UNREAD) };
+    let value = |s: &[u8]| match *s {
+        [hi, lo] => u16::from_be_bytes([hi, lo]) as f32 / 65535.0,
+        [v] => v as f32 / 255.0,
+        _ => 0.0,
+    };
+    let inks = raw
+        .chunks_exact(size * 4)
+        .flat_map(|px| px.chunks_exact(size).zip(ranges).map(|(s, (lo, hi))| ((lo + value(s) * (hi - lo)).clamp(0.0, 1.0) * 255.0).round() as u8))
+        .collect();
+    Inks::new(width, height, inks).and_then(|i| ImageBlob::cmyk_tiff(&i)).map(Some).ok_or(UNREAD)
+}

crates/pdf/src/import_scan.rs

@@ -1,6 +1,6 @@
 //! What the interpreter doesn't tell the import, read from the file itself: the optional content
-//! groups (layers) with their states, which group each marked-content sequence belongs to, the
-//! isolate and knockout flags of transparency groups, and the names of the fonts.
+//! groups (layers) with their states and nesting, which group each marked-content sequence belongs
+//! to, the isolate and knockout flags of transparency groups, and the names of the fonts.
 //!
 //! hayro-interpret reports a marked-content sequence by its tag alone and a transparency group
 //! without its flags, and skips the content of groups that are off. So each page's content is
@@ -16,7 +16,7 @@ use hayro_interpret::CacheKey;
 use hayro_syntax::Pdf;
 use hayro_syntax::content::TypedIter;
 use hayro_syntax::content::ops::TypedInstruction;
-use hayro_syntax::object::{Array, Dict, FromBytes, Name, Object, ObjectIdentifier, dict_or_stream};
+use hayro_syntax::object::{Array, Dict, FromBytes, MaybeRef, Name, Object, ObjectIdentifier, dict_or_stream};
 use hayro_syntax::page::{Page, Resources};
 
 /// The interpreter's limit on nested form XObjects.
@@ -25,6 +25,8 @@ const MAX_DEPTH: u32 = 50;
 const MAX_OPS: usize = 2_000_000;
 /// The most groups read.
 const MAX_GROUPS: usize = 10_000;
+/// The deepest layers nest in the configuration's `/Order`.
+pub(crate) const MAX_NESTING: usize = 32;
 
 /// An optional content group: a layer.
 #[derive(Clone, Debug, PartialEq)]
@@ -35,6 +37,8 @@ pub(crate) struct Ocg {
     /// Printed (its print usage isn't off).
     pub print: bool,
     pub locked: bool,
+    /// The group it is listed under in the layer order (a sublayer of it).
+    pub parent: Option<usize>,
 }
 
 /// The file's optional content groups.
@@ -44,6 +48,10 @@ pub(crate) struct Ocgs {
     index: HashMap<ObjectIdentifier, usize>,
     /// The groups that are off (as the interpreter decides it).
     off: HashSet<ObjectIdentifier>,
+    /// The groups whose view state applies when the file opens (an `/AS` entry for viewing).
+    view_auto: HashSet<ObjectIdentifier>,
+    /// The groups placed in the layer order.
+    placed: HashSet<usize>,
 }
 
 impl Ocgs {
@@ -68,35 +76,88 @@ impl Ocgs {
             o.off.remove(&id);
         }
         o.off.extend(refs(&config, b"OFF"));
+        let auto = config.get::<Array<'_>>(b"AS").map(|a| a.iter::<Dict<'_>>().take(MAX_GROUPS).collect::<Vec<_>>()).unwrap_or_default();
+        for d in auto.iter().filter(|d| d.get::<Name<'_>>(b"Event").is_some_and(|e| e.as_ref() == b"View")) {
+            o.view_auto.extend(refs(d, b"OCGs"));
+        }
         let locked: HashSet<_> = refs(&config, b"Locked").into_iter().collect();
         for id in all {
             if let Some(d) = xref.get::<Dict<'_>>(id) {
                 o.add(id, &d, locked.contains(&id));
             }
         }
+        if let Some(order) = config.get::<Array<'_>>(b"Order") {
+            o.nest(&order, None, 0, xref, &mut 0);
+        }
         o
     }
 
+    /// Read the layer order `order` (listed under group `parent`): a group followed by an array
+    /// lists that array's groups as its sublayers; an array starting with a label lists its
+    /// groups under the label, which isn't a group (they go under `parent`). A group listed twice
+    /// stays where it is first listed. `seen`: the entries read so far.
+    fn nest(&mut self, order: &Array<'_>, parent: Option<usize>, depth: usize, xref: &hayro_syntax::xref::XRef, seen: &mut usize) {
+        let mut prev = None;
+        for item in order.raw_iter() {
+            *seen += 1;
+            if *seen > 4 * MAX_GROUPS {
+                return;
+            }
+            let sub = match item {
+                MaybeRef::Ref(r) => {
+                    let id = ObjectIdentifier::from(r);
+                    let sub = xref.get::<Array<'_>>(id);
+                    if sub.is_none() {
+                        prev = self.place(id, parent);
+                    }
+                    sub
+                }
+                MaybeRef::NotRef(o) => o.into_array(),
+            };
+            if let Some(sub) = sub
+                && depth < MAX_NESTING
+            {
+                let label = matches!(sub.raw_iter().next(), Some(MaybeRef::NotRef(Object::String(_))));
+                let under = prev.take().filter(|_| !label).or(parent);
+                self.nest(&sub, under, depth + 1, xref, seen);
+            }
+        }
+    }
+
+    /// Put group `id` under `parent` in the layer order → its index, unless it isn't a group or
+    /// is already placed. Each group is placed after its parent, so the nesting has no cycles.
+    fn place(&mut self, id: ObjectIdentifier, parent: Option<usize>) -> Option<usize> {
+        let i = *self.index.get(&id)?;
+        let placed = self.placed.insert(i);
+        let g = self.list.get_mut(i).filter(|_| placed)?;
+        g.parent = parent;
+        Some(i)
+    }
+
     /// Note group `id` (its dictionary `d`) → its index.
     fn add(&mut self, id: ObjectIdentifier, d: &Dict<'_>, locked: bool) -> usize {
         if let Some(i) = self.index.get(&id) {
             return *i;
         }
         let name = d.get::<hayro_syntax::object::String<'_>>(b"Name").map(|s| text_string(s.as_bytes())).unwrap_or_default();
-        let print = d
-            .get::<Dict<'_>>(b"Usage")
-            .and_then(|u| u.get::<Dict<'_>>(b"Print"))
-            .and_then(|p| p.get::<Name<'_>>(b"PrintState"))
-            .is_none_or(|s| s.as_ref() != b"OFF");
-        let on = !self.off.contains(&id);
-        self.list.push(Ocg { name: if name.is_empty() { format!("Layer {}", self.list.len() + 1) } else { name }, on, print, locked });
+        let print = usage(d, b"Print", b"PrintState") != Some(false);
+        // A view state applies when the configuration says so on opening; an off one hides the
+        // group all the same (it says how the group is meant to be seen).
+        let view = usage(d, b"View", b"ViewState");
+        let on = match view {
+            Some(v) if self.view_auto.contains(&id) => v,
+            Some(false) => false,
+            _ => !self.off.contains(&id),
+        };
+        let name = if name.is_empty() { format!("Layer {}", self.list.len() + 1) } else { name };
+        self.list.push(Ocg { name, on, print, locked, parent: None });
         self.index.insert(id, self.list.len() - 1);
         self.list.len() - 1
     }
 
-    /// Is any group off?
-    pub fn any_off(&self) -> bool {
-        self.list.iter().any(|g| !g.on)
+    /// Does the interpreter leave out the art of some group (off in the default configuration)?
+    pub fn skips_any(&self) -> bool {
+        self.index.keys().any(|id| self.off.contains(id))
     }
 
     /// The group content marked with `/OC` (`d`: the group or membership dictionary, `id` its
@@ -119,6 +180,16 @@ impl Ocgs {
     }
 }
 
+/// The state (`ON` → true, `OFF` → false) group `d`'s usage `category` gives in `key`.
+fn usage(d: &Dict<'_>, category: &[u8], key: &[u8]) -> Option<bool> {
+    let state = d.get::<Dict<'_>>(b"Usage")?.get::<Dict<'_>>(category)?.get::<Name<'_>>(key)?;
+    match state.as_ref() {
+        b"ON" => Some(true),
+        b"OFF" => Some(false),
+        _ => None,
+    }
+}
+
 /// A PDF text string: UTF-16 (with its byte order mark), UTF-8 (with one) or PDFDocEncoding
 /// (read as Latin-1, which it matches for letters).
 pub(crate) fn text_string(b: &[u8]) -> String {

crates/pdf/src/lib.rs

@@ -47,6 +47,7 @@ mod forms;
 mod images;
 mod import;
 mod import_color;
+mod import_image;
 mod import_mask;
 mod import_scan;
 mod import_shading;
@@ -210,6 +211,8 @@ mod tests_charstroke;
 #[cfg(test)]
 mod tests_cmykblend;
 #[cfg(test)]
+mod tests_cmykimages;
+#[cfg(test)]
 mod tests_compression;
 #[cfg(test)]
 mod tests_dashalign;

crates/pdf/src/output.rs

@@ -6,7 +6,8 @@
 //!   model when their profile differs from the destination; `preserveNumbers` converts only the
 //!   colours of the other model (and Lab ones), keeping the numbers of those already in it.
 //!   Grey stays grey. Images (and freeform gradients' images) are converted the same way, pixel
-//!   by pixel; printer's marks are not. The destination is a profile name; empty, the document's
+//!   by pixel (CMYK images too: they keep their numbers unless converted, see [`CmykPixels`]);
+//!   printer's marks are not. The destination is a profile name; empty, the document's
 //!   profile for its colour mode.
 //! - Profiles ([`ProfileInclusion`]): with `all`, with `destination`, and with `taggedSource` on a
 //!   document that was assigned profiles, colours are written in ICC-based colour spaces: CMYK
@@ -23,8 +24,9 @@
 
 use std::sync::{Arc, OnceLock};
 
+use krilla::image::ImageColorspace;
 use vectorcraft_color::Color;
-use vectorcraft_color::cms::{self, Cms, Intent, Model, ProfileKind, ProofLut};
+use vectorcraft_color::cms::{self, Cms, CmykLut, Intent, Model, ProfileKind, ProofLut};
 use vectorcraft_doc::{ColorMode, Document};
 
 use crate::patch::{Patch, Xref};
@@ -58,6 +60,8 @@ pub(crate) struct ColorOut {
     pub srgb_note: Option<String>,
     /// The image transform, built when the first image needs it.
     pixels: OnceLock<Option<Pixels>>,
+    /// The CMYK image transform, built when the first CMYK image needs it.
+    cmyk_pixels: OnceLock<Option<CmykPixels>>,
     intent: Intent,
     /// The output intent and Trapped entries to write.
     catalog: Option<Catalog>,
@@ -97,6 +101,7 @@ impl Default for ColorOut {
             cmyk_profile,
             srgb_note: None,
             pixels: OnceLock::new(),
+            cmyk_pixels: OnceLock::new(),
             intent,
             catalog: None,
             standard: Standard::None,
@@ -276,6 +281,30 @@ impl ColorOut {
             .as_ref()
     }
 
+    /// How CMYK images' ink amounts are converted; `None` when they keep their numbers (no
+    /// conversion, or to a CMYK destination that keeps them).
+    pub(crate) fn cmyk_pixels(&self) -> Option<&CmykPixels> {
+        self.cmyk_pixels
+            .get_or_init(|| {
+                let d = self.dest.as_ref().filter(|d| !(d.keep && d.model == Model::Cmyk))?;
+                let cmyk = d.model == Model::Cmyk;
+                // Each ink combination as a CMYK colour is written.
+                let lut = CmykLut::build(|[c, m, y, k]| {
+                    let out = self.color(&Color::Cmyk { c, m, y, k }, self.intent, false, true);
+                    if cmyk {
+                        return d.cms.to_cmyk(&out, self.intent);
+                    }
+                    let [r, g, b] = match out {
+                        Color::Rgb { r, g, b } => [r, g, b],
+                        other => d.cms.srgb_to_rgb(d.cms.display_rgb(&other)),
+                    };
+                    [r, g, b, 0.0]
+                });
+                Some(CmykPixels { lut, cmyk })
+            })
+            .as_ref()
+    }
+
     /// `pdf` with the output intent and Trapped entries, and a PDF/X file's identification
     /// ([`crate::pdfx`]) → (the file, warnings).
     pub(crate) fn write_catalog(&self, pdf: Vec<u8>) -> Result<(Vec<u8>, Vec<String>), PdfError> {
@@ -424,10 +453,6 @@ pub(crate) enum Pixels {
 }
 
 impl Pixels {
-    pub(crate) fn is_cmyk(&self) -> bool {
-        matches!(self, Self::Cmyk(_))
-    }
-
     /// Convert the RGB samples of straight RGBA pixels `rgba` in place (RGB destinations).
     pub(crate) fn rgb_in_place(&self, rgba: &mut [u8]) {
         if let Self::Rgb(lut) = self {
@@ -455,3 +480,30 @@ impl Pixels {
         )
     }
 }
+
+/// How CMYK images' ink amounts are converted to the destination: a lookup table to its RGB
+/// values, or to its CMYK ones (another profile).
+pub(crate) struct CmykPixels {
+    lut: CmykLut,
+    /// The destination is CMYK.
+    cmyk: bool,
+}
+
+impl CmykPixels {
+    /// Ink amounts `inks` (four bytes a pixel) converted → (the samples, their colour space).
+    pub(crate) fn convert(&self, inks: &[u8]) -> (Vec<u8>, ImageColorspace) {
+        let n = if self.cmyk { 4 } else { 3 };
+        let mut out = Vec::with_capacity(inks.len() / 4 * n);
+        // Runs of one colour convert once.
+        let mut last: Option<([u8; 4], [u8; 4])> = None;
+        for p in inks.as_chunks::<4>().0 {
+            let v = match last {
+                Some((k, v)) if k == *p => v,
+                _ => self.lut.apply8(*p),
+            };
+            last = Some((*p, v));
+            out.extend_from_slice(v.get(..n).unwrap_or_default());
+        }
+        (out, if self.cmyk { ImageColorspace::Cmyk } else { ImageColorspace::Rgb })
+    }
+}

crates/pdf/src/tests_cmykimages.rs

@@ -0,0 +1,292 @@
+//! CMYK images keep their CMYK samples from import to export (issue #320): a CMYK JPEG passes
+//! through unchanged, other CMYK images keep their ink amounts, and only the Output settings
+//! convert them.
+
+use std::sync::Arc;
+
+use hayro_syntax::Pdf;
+use hayro_syntax::object::{Array, Name, Object, Stream};
+use serde_json::json;
+use vectorcraft_color::cms::{self, DEVICE_CMYK, GENERIC_CMYK, SRGB};
+use vectorcraft_doc::cmyk::Inks;
+use vectorcraft_doc::{ColorMode, Document, ImageBlob, ImageObject, Node, NodeKind};
+use vectorcraft_geom::Affine;
+
+use crate::*;
+
+/// `inks` (four bytes a pixel) as a CMYK JPEG: Adobe's inverted samples, with its marker.
+fn cmyk_jpeg(inks: &[u8], w: u16, h: u16) -> Vec<u8> {
+    let mut out = Vec::new();
+    jpeg_encoder::Encoder::new(&mut out, 100).encode(inks, w, h, jpeg_encoder::ColorType::Cmyk).unwrap();
+    out
+}
+
+fn flat(inks: [u8; 4], n: usize) -> Vec<u8> {
+    inks.repeat(n)
+}
+
+fn stream(dict: &str, data: &[u8]) -> Vec<u8> {
+    let mut s = format!("<< {dict} /Length {} >>\nstream\n", data.len()).into_bytes();
+    s.extend_from_slice(data);
+    s.extend_from_slice(b"\nendstream");
+    s
+}
+
+/// A 300 × 100 pt page with a CMYK rectangle and image XObjects `images` (dictionary entries
+/// after the type, stream data), 50 pt wide each: objects 5…, then the `extra` objects.
+fn pdf_with_images(images: &[(String, Vec<u8>)], extra: &[Vec<u8>]) -> Vec<u8> {
+    let xobjects: String = (0..images.len()).map(|i| format!("/Im{i} {} 0 R ", 5 + i)).collect();
+    let mut content = String::from("0 1 0.6 0.2 k 0 80 300 20 re f\n");
+    for i in 0..images.len() {
+        content.push_str(&format!("q 50 0 0 50 {} 10 cm /Im{i} Do Q\n", 10 + 60 * i));
+    }
+    let mut objs = vec![
+        b"<< /Type /Catalog /Pages 2 0 R >>".to_vec(),
+        b"<< /Type /Pages /Kids [3 0 R] /Count 1 >>".to_vec(),
+        format!("<< /Type /Page /Parent 2 0 R /MediaBox [0 0 300 100] /Resources << /XObject << {xobjects}>> >> /Contents 4 0 R >>").into_bytes(),
+        stream("", content.as_bytes()),
+    ];
+    for (dict, data) in images {
+        objs.push(stream(&format!("/Type /XObject /Subtype /Image {dict}"), data));
+    }
+    objs.extend_from_slice(extra);
+    let mut out = b"%PDF-1.4\n".to_vec();
+    let mut at = vec![];
+    for (i, o) in objs.iter().enumerate() {
+        at.push(out.len());
+        out.extend_from_slice(format!("{} 0 obj\n", i + 1).as_bytes());
+        out.extend_from_slice(o);
+        out.extend_from_slice(b"\nendobj\n");
+    }
+    let xref = out.len();
+    out.extend_from_slice(format!("xref\n0 {}\n0000000000 65535 f \n", objs.len() + 1).as_bytes());
+    for a in at {
+        out.extend_from_slice(format!("{a:010} 00000 n \n").as_bytes());
+    }
+    out.extend_from_slice(format!("trailer\n<< /Size {} /Root 1 0 R >>\nstartxref\n{xref}\n%%EOF\n", objs.len() + 1).as_bytes());
+    out
+}
+
+/// An image dictionary's entries: `w` × `h` CMYK pixels, with `more`.
+fn cmyk_dict(w: u32, h: u32, more: &str) -> String {
+    format!("/Width {w} /Height {h} /ColorSpace /DeviceCMYK /BitsPerComponent 8 {more}")
+}
+
+const INVERTED: &str = "/Decode [1 0 1 0 1 0 1 0]";
+
+/// An image XObject of a written PDF: its colour space and the components of its ICC profile,
+/// its Decode array, its filter and its stream data.
+#[derive(Debug)]
+struct Written {
+    space: String,
+    icc_n: Option<u8>,
+    decode: Vec<f32>,
+    filter: Option<String>,
+    data: Vec<u8>,
+    width: u32,
+}
+
+fn written(pdf: &[u8]) -> Vec<Written> {
+    let file = Pdf::new(Arc::new(pdf.to_vec())).unwrap();
+    let mut out = vec![];
+    for o in file.objects() {
+        let Object::Stream(s) = o else { continue };
+        let d = s.dict();
+        if d.get::<Name<'_>>(b"Subtype").is_none_or(|n| n.as_ref() != b"Image") {
+            continue;
+        }
+        let (space, icc_n) = match (d.get::<Name<'_>>(b"ColorSpace"), d.get::<Array<'_>>(b"ColorSpace")) {
+            (Some(n), _) => (n.as_str().to_string(), None),
+            (_, Some(a)) => {
+                let mut it = a.flex_iter();
+                let name = it.next::<Name<'_>>().unwrap().as_str().to_string();
+                (name, it.next::<Stream<'_>>().and_then(|s| s.dict().get::<u8>(b"N")))
+            }
+            _ => (String::new(), None),
+        };
+        out.push(Written {
+            space,
+            icc_n,
+            decode: d.get::<Array<'_>>(b"Decode").map(|a| a.iter::<f32>().collect()).unwrap_or_default(),
+            filter: d.get::<Name<'_>>(b"Filter").map(|n| n.as_str().to_string()),
+            data: s.raw_data().to_vec(),
+            width: d.get::<u32>(b"Width").unwrap_or(0),
+        });
+    }
+    out
+}
+
+/// The blob each image of `d` shows, in paint order.
+fn blobs(d: &Document) -> Vec<&ImageBlob> {
+    let NodeKind::Layer { children, .. } = &d.layers[0].kind else { panic!() };
+    children
+        .iter()
+        .filter_map(|n| match &n.kind {
+            NodeKind::Image(im) => d.images.get(&im.key),
+            _ => None,
+        })
+        .collect()
+}
+
+/// Options with settings `s` (at their standard's version).
+fn opts(s: serde_json::Value) -> PdfOptions {
+    let settings: PdfSettings = serde_json::from_value(s).unwrap();
+    let compatibility = if settings.standard == Standard::None { settings.compatibility } else { settings.standard.version() };
+    PdfOptions { settings: PdfSettings { compatibility, ..settings }, created: Some(1_700_000_000), ..Default::default() }
+}
+
+fn close(a: &[u8], b: &[u8], tolerance: u8) -> bool {
+    a.len() == b.len() && a.iter().zip(b).all(|(x, y)| x.abs_diff(*y) <= tolerance)
+}
+
+#[test]
+fn a_cmyk_jpeg_passes_through_open_and_every_pdf_export() {
+    // The issue's file: a DeviceCMYK JPEG (Adobe's inverted samples, Decode [1 0 …]) beside a
+    // DeviceCMYK fill.
+    let jpg = cmyk_jpeg(&flat([0, 102, 255, 0], 32 * 16), 32, 16);
+    let source = pdf_with_images(&[(cmyk_dict(32, 16, &format!("/Filter /DCTDecode {INVERTED}")), jpg.clone())], &[]);
+    let r = import_with_report(&source, &ImportOptions::default()).unwrap();
+    assert_eq!(r.document.color_mode, ColorMode::Cmyk);
+    let b = blobs(&r.document);
+    assert_eq!(b.len(), 1);
+    assert_eq!((b[0].mime.as_str(), b[0].bytes.as_slice()), ("image/jpeg", jpg.as_slice()), "the JPEG as it is");
+    assert!(b[0].cmyk().unwrap().data.as_chunks::<4>().0.iter().all(|p| close(p, &[0, 102, 255, 0], 2)));
+    assert!(r.warnings.is_empty(), "{:?}", r.warnings);
+
+    for (settings, space, icc_n) in [
+        (json!({}), "DeviceCMYK", None),
+        (json!({"output": {"conversion": "preserveNumbers"}}), "DeviceCMYK", None),
+        (json!({"standard": "pdfX1a"}), "DeviceCMYK", None),
+        (json!({"standard": "pdfX3"}), "ICCBased", Some(4)),
+        (json!({"standard": "pdfX4"}), "ICCBased", Some(4)),
+        (json!({"output": {"profiles": "all"}}), "ICCBased", Some(4)),
+    ] {
+        let out = export_with_report(&r.document, &opts(settings.clone())).unwrap();
+        let w = written(&out.bytes);
+        assert_eq!(w.len(), 1, "{settings}: {w:?}");
+        assert_eq!((w[0].space.as_str(), w[0].icc_n), (space, icc_n), "{settings}");
+        assert_eq!(w[0].filter.as_deref(), Some("DCTDecode"), "{settings}");
+        assert_eq!(w[0].decode, [1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0], "{settings}");
+        assert!(w[0].data == jpg, "{settings}: the JPEG data unchanged");
+        assert!(out.warnings.iter().all(|w| !w.contains("image")), "{settings}: {:?}", out.warnings);
+        // And open again: the same JPEG.
+        let back = import(&out.bytes).unwrap();
+        assert_eq!(blobs(&back)[0].bytes.as_slice(), jpg.as_slice(), "{settings}");
+    }
+}
+
+#[test]
+fn other_cmyk_images_keep_their_ink_amounts() {
+    let inks: Vec<u8> = [[0, 0, 0, 0], [255, 0, 0, 0], [10, 20, 30, 40], [0, 102, 255, 0]].concat();
+    let z = |data: &[u8]| crate::output::deflate(data).unwrap();
+    let inverted: Vec<u8> = inks.iter().map(|v| 255 - v).collect();
+    let wide: Vec<u8> = inks.iter().flat_map(|v| (*v as u16 * 257).to_be_bytes()).collect();
+    let images = [
+        (cmyk_dict(2, 2, "/Filter /FlateDecode"), z(&inks)),
+        (cmyk_dict(2, 2, &format!("/Filter /FlateDecode {INVERTED}")), z(&inverted)),
+        (cmyk_dict(2, 2, "/Filter /FlateDecode").replace("/BitsPerComponent 8", "/BitsPerComponent 16"), z(&wide)),
+        // A CMYK JPEG holding the ink amounts themselves (no Decode array): not Adobe's convention.
+        (cmyk_dict(2, 2, "/Filter /DCTDecode"), cmyk_jpeg(&inverted, 2, 2)),
+        // ICC-based with four components (object 10: after the page's 4 objects and 5 images).
+        (cmyk_dict(2, 2, "/Filter /FlateDecode").replace("/DeviceCMYK", "[/ICCBased 10 0 R]"), z(&inks)),
+    ];
+    let source = pdf_with_images(&images, &[stream("/N 4", b"")]);
+    let r = import_with_report(&source, &ImportOptions::default()).unwrap();
+    let b = blobs(&r.document);
+    assert_eq!(b.len(), 5, "{:?}", r.warnings);
+    for (i, blob) in b.iter().enumerate() {
+        assert_eq!(blob.mime, "image/tiff", "image {i}");
+        let got = blob.cmyk().unwrap();
+        assert_eq!((got.width, got.height), (2, 2));
+        let tolerance = if i == 3 { 3 } else { 0 };
+        assert!(close(&got.data, &inks, tolerance), "image {i}: {:?}", got.data);
+    }
+    // Written as CMYK, losslessly: they open with the same ink amounts.
+    let out = export_with_report(&r.document, &opts(json!({}))).unwrap();
+    let w = written(&out.bytes);
+    assert!(!w.is_empty() && w.iter().all(|w| w.space == "DeviceCMYK" && w.decode.is_empty()), "{w:?}");
+    let back = import(&out.bytes).unwrap();
+    for blob in blobs(&back) {
+        assert!(close(&blob.cmyk().unwrap().data, &inks, 3));
+    }
+}
+
+#[test]
+fn cmyk_images_with_a_mask_or_odd_samples_open_in_rgb_with_a_warning() {
+    let inks = flat([0, 102, 255, 0], 4);
+    let mask = stream("/Type /XObject /Subtype /Image /Width 2 /Height 2 /ColorSpace /DeviceGray /BitsPerComponent 8", &[255, 128, 255, 128]);
+    let source = pdf_with_images(&[(cmyk_dict(2, 2, "/SMask 6 0 R /Filter /FlateDecode"), crate::output::deflate(&inks).unwrap())], &[mask]);
+    let r = import_with_report(&source, &ImportOptions::default()).unwrap();
+    assert_eq!(blobs(&r.document)[0].mime, "image/png");
+    assert!(r.warnings.iter().any(|w| w == crate::import_image::MASKED), "{:?}", r.warnings);
+    let four_bits = cmyk_dict(2, 2, "").replace("/BitsPerComponent 8", "/BitsPerComponent 4");
+    let r = import_with_report(&pdf_with_images(&[(four_bits, vec![0x0F; 8])], &[]), &ImportOptions::default()).unwrap();
+    assert_eq!(blobs(&r.document)[0].mime, "image/png");
+    assert!(r.warnings.iter().any(|w| w == crate::import_image::UNREAD), "{:?}", r.warnings);
+}
+
+/// A document with CMYK image `blob` of `w` × `h` pixels placed 40 pt wide.
+fn image_doc(blob: ImageBlob, w: u32, h: u32) -> Document {
+    let mut d = Document::new_with_mode(100.0, 100.0, ColorMode::Cmyk);
+    d.images.insert("img".into(), blob);
+    let image = ImageObject { key: "img".into(), width: w, height: h, xf: Affine::scale(40.0 / w as f64), link: None, placement: Default::default() };
+    let n = Node::new(d.alloc_id(), NodeKind::Image(image));
+    let l = d.layers[0].id;
+    d.insert(Some(l), 0, n).unwrap();
+    d
+}
+
+#[test]
+fn the_output_settings_convert_cmyk_images_and_compression_recompresses_them_in_cmyk() {
+    let ink = [0u8, 102, 255, 0];
+    let tiff = ImageBlob::cmyk_tiff(&Inks::new(4, 4, flat(ink, 16)).unwrap()).unwrap();
+    let d = image_doc(tiff, 4, 4);
+    let first = |s: serde_json::Value| {
+        let out = export_with_report(&d, &opts(s.clone())).unwrap();
+        let w = written(&out.bytes);
+        assert_eq!(w.len(), 1, "{s}");
+        let back = import(&out.bytes).unwrap();
+        let blob = blobs(&back)[0].clone();
+        (w.into_iter().next().unwrap(), blob, out.warnings)
+    };
+    // Kept: its numbers.
+    for s in [json!({}), json!({"output": {"conversion": "preserveNumbers", "destination": DEVICE_CMYK}})] {
+        let (w, blob, warnings) = first(s.clone());
+        assert_eq!(w.space, "DeviceCMYK", "{s}");
+        assert_eq!(blob.cmyk().unwrap().data, flat(ink, 16), "{s}");
+        assert!(warnings.is_empty(), "{s}: {warnings:?}");
+    }
+    // To another CMYK profile: other numbers, still CMYK.
+    let (w, blob, _) = first(json!({"output": {"conversion": "destination", "destination": DEVICE_CMYK}}));
+    assert_eq!(w.space, "DeviceCMYK");
+    let converted = blob.cmyk().unwrap().data;
+    assert_ne!(converted, flat(ink, 16));
+    let source = cms::active();
+    let dest = cms::Cms::new(&cms::ColorSettings { cmyk: DEVICE_CMYK.into(), ..source.settings().clone() }).unwrap();
+    let want = dest.lab_to_cmyk(source.cmyk_to_lab(ink.map(|v| v as f32 / 255.0)), source.settings().intent).map(|v| (v * 255.0).round() as u8);
+    assert!(close(&converted[..4], &want, 3), "{converted:?} vs {want:?}");
+    // To RGB: the colour shown on screen.
+    let (w, blob, _) = first(json!({"output": {"conversion": "destination", "destination": SRGB}}));
+    assert_eq!(w.space, "DeviceRGB");
+    let shown = source.cmyk_to_srgb(ink.map(|v| v as f32 / 255.0), false).map(|v| (v * 255.0).round() as u8);
+    let px = image::load_from_memory(&blob.bytes).unwrap().to_rgb8().get_pixel(0, 0).0;
+    assert!(close(&px, &shown, 3), "{px:?} vs {shown:?}");
+    // JPEG compression: a CMYK JPEG (Adobe's inverted samples, undone by the Decode array).
+    let (w, blob, warnings) = first(json!({"compression": {"color": {"compression": "jpeg", "quality": "maximum"}}}));
+    assert_eq!((w.space.as_str(), w.filter.as_deref()), ("DeviceCMYK", Some("DCTDecode")));
+    assert_eq!(w.decode, [1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0]);
+    assert!(warnings.is_empty(), "{warnings:?}");
+    assert!(blob.cmyk().unwrap().data.as_chunks::<4>().0.iter().all(|p| close(p, &ink, 3)));
+    // Resampled: fewer pixels, the same inks.
+    let jpg = ImageBlob::new("image/jpeg", cmyk_jpeg(&flat(ink, 64 * 64), 64, 64));
+    let d = image_doc(jpg, 64, 64);
+    let s = json!({"compression": {"color": {"downsample": "bicubic", "ppi": 72.0, "abovePpi": 100.0}}});
+    let out = export_with_report(&d, &opts(s)).unwrap();
+    let w = written(&out.bytes);
+    assert_eq!((w[0].space.as_str(), w[0].width), ("DeviceCMYK", 40), "{w:?}");
+    assert!(blobs(&import(&out.bytes).unwrap())[0].cmyk().unwrap().data.as_chunks::<4>().0.iter().all(|p| close(p, &ink, 3)));
+    // And PDF/X-1a keeps the numbers of a CMYK image (no conversion through RGB).
+    let (w, blob, _) = first(json!({"standard": "pdfX1a", "output": {"destination": GENERIC_CMYK}}));
+    assert_eq!(w.space, "DeviceCMYK");
+    assert_eq!(blob.cmyk().unwrap().data, flat(ink, 16));
+}

crates/pdf/src/tests_import_fidelity.rs

@@ -1,11 +1,11 @@
 //! Import fidelity: soft masks → opacity masks, isolated and knockout groups, tiling patterns →
 //! pattern swatches, text → point type, mesh shadings → gradient meshes, gradient stop opacity
-//! and shading Extend flags.
+//! and shading Extend flags; strokes stay live strokes.
 
 use std::sync::Arc;
 
 use vectorcraft_color::{BlendMode, Color, Gradient, GradientKind, GradientPaint, GradientStop, Paint};
-use vectorcraft_doc::{Appearance, AppearanceItem, Document, Knockout, Node, NodeId, NodeKind, OpacityMask};
+use vectorcraft_doc::{Appearance, AppearanceItem, Document, Knockout, LineCap, LineJoin, Node, NodeId, NodeKind, OpacityMask};
 use vectorcraft_geom::{Rect, shapes};
 use vectorcraft_testkit::pdf::{PdfPage, first_extra, pdf_with};
 
@@ -390,3 +390,57 @@ fn glyphs_turned_along_a_curve_become_type_on_a_path() {
     assert_eq!(straight.len(), 1);
     assert!(matches!(straight[0].kind, vectorcraft_doc::TextKind::Point), "{:?}", straight[0].kind);
 }
+
+/// The leaves (objects that aren't groups or clipping paths) of a document.
+fn objects(d: &Document) -> Vec<Node> {
+    all(d).into_iter().filter(|n| !n.is_container() && !matches!(n.kind, NodeKind::Path { clipping: true, .. })).collect()
+}
+
+#[test]
+fn an_object_written_as_a_fill_and_a_closed_stroke_stays_one_path_with_a_live_stroke() {
+    // As Illustrator writes an object: the fill of the outline left open, then the stroke of it
+    // closed, each in its own transform. Two subpaths: one ending on its start, one not.
+    let outline = "0 0 m -20 1 l -30 -12 l -30 30 l 0 0 l 5 5 m 10 5 l 10 10 l";
+    let content = format!(
+        "0.2 0.2 0.2 rg q 1 0 0 1 50 50 cm {outline} f Q 1 1 1 RG 1.5 w 1 J 1 j 4 M [3 2] 1 d q 1 0 0 1 50 50 cm {} S Q",
+        outline.replace(" 5 5 m", " h 5 5 m") + " h"
+    );
+    let d = open(&one_page(&content, "", &[]));
+    let objs = objects(&d);
+    assert_eq!(objs.len(), 1, "one object, not a fill and a separate stroke: {objs:#?}");
+    let n = &objs[0];
+    assert_eq!(fill_color(n), Some(Color::rgb(0.2, 0.2, 0.2)));
+    let st = n.appearance.stroke().expect("a live stroke");
+    assert_eq!(st.paint.color(), Some(Color::WHITE));
+    assert!((st.width - 1.5).abs() < 1e-6);
+    assert_eq!((st.cap, st.join), (LineCap::Round, LineJoin::Round));
+    assert!((st.miter_limit - 4.0).abs() < 1e-6);
+    let dash = st.dash.as_ref().expect("dashed");
+    assert_eq!((dash.pattern.as_slice(), dash.offset), (&[3.0, 2.0][..], 1.0));
+    // The stroke's outline: both subpaths closed, as they were stroked.
+    let p = n.path_data().unwrap();
+    assert_eq!(p.subpaths.len(), 2);
+    assert!(p.is_closed());
+}
+
+#[test]
+fn different_outlines_filled_and_stroked_stay_apart() {
+    let d = open(&one_page("1 0 0 rg 10 10 m 40 10 l 40 40 l f 0 0 1 RG 10 10 m 40 10 l 40 40 l 10 40 l h S 0 g 50 50 m 60 60 l S", "", &[]));
+    let objs = objects(&d);
+    assert_eq!(objs.len(), 3);
+    assert!(objs[0].appearance.stroke().is_none() && objs[1].appearance.fill().is_none());
+}
+
+#[test]
+fn a_stroke_under_a_stretched_transform_stays_a_stroke() {
+    // Stretched twice as wide: the stroke keeps its average width (√2 × 2 pt) rather than
+    // becoming a filled outline.
+    let d = open(&one_page("0 0 1 RG 2 w q 2 0 0 1 0 0 cm 10 10 m 40 10 l 40 40 l S Q", "", &[]));
+    let objs = objects(&d);
+    assert_eq!(objs.len(), 1);
+    assert!(objs[0].appearance.fill().is_none());
+    let st = objs[0].appearance.stroke().expect("a stroke");
+    assert!((st.width - 2.0 * 2f64.sqrt()).abs() < 1e-6, "{}", st.width);
+    let b = objs[0].geometric_bounds().unwrap();
+    assert!((b.x0 - 20.0).abs() < 1e-6 && (b.x1 - 80.0).abs() < 1e-6, "{b:?}");
+}

crates/pdf/src/tests_import_layers.rs

@@ -1,5 +1,5 @@
-//! Optional content groups become layers: name, visibility, print state and lock; art that is
-//! off comes in as a hidden layer.
+//! Optional content groups become layers: name, visibility (the default configuration's or the
+//! view state's), print state, lock and nesting; art that is off comes in as a hidden layer.
 
 use vectorcraft_color::Color;
 use vectorcraft_doc::{Document, Node, NodeKind};
@@ -192,3 +192,109 @@ fn a_page_fill_that_is_art_stays() {
     assert_eq!(names(&d), ["Shapes", "Page 1"]);
     assert_eq!(path_count(&d), 3);
 }
+
+/// A page drawing a red, a blue and a green square in groups `defs` (as `/MC0`–`/MC2`), the
+/// catalog listing them with default configuration `config`, plus `more` objects; in `config` and
+/// `more`, `{0}`–`{2}` stand for the groups.
+fn three_groups(defs: [&str; 3], more: &[&str], config: &str) -> Vec<u8> {
+    let refs = [0, 1, 2].map(|i| format!("{} 0 R", first_extra(1) + i));
+    let fill = |s: &str| (0..3).fold(s.to_string(), |s, i| s.replace(&format!("{{{i}}}"), &refs[i]));
+    let content = "/OC /MC0 BDC 1 0 0 rg 10 10 20 20 re f EMC /OC /MC1 BDC 0 0 1 rg 40 40 20 20 re f EMC /OC /MC2 BDC 0 1 0 rg 70 70 20 20 re f EMC";
+    let page = PdfPage { resources: fill("/Properties << /MC0 {0} /MC1 {1} /MC2 {2} >>"), ..PdfPage::new(100.0, 100.0, content) };
+    let catalog = format!("/OCProperties << /OCGs [{}] /D << {} >> >> ", refs.join(" "), fill(config));
+    let more: Vec<String> = more.iter().map(|m| fill(m)).collect();
+    let objs: Vec<&str> = defs.iter().copied().chain(more.iter().map(String::as_str)).collect();
+    pdf_with_catalog(&[page], &objs, &catalog, None)
+}
+
+fn ocg(name: &str, usage: &str) -> String {
+    format!("<< /Type /OCG /Name ({name}) {usage} >>")
+}
+
+fn visibility(layers: &[std::sync::Arc<Node>]) -> Vec<bool> {
+    layers.iter().map(|l| l.visible).collect()
+}
+
+#[test]
+fn a_view_state_that_is_off_hides_the_layer_with_its_art() {
+    let off = ocg("Off", "/Usage << /View << /ViewState /OFF >> >>");
+    // With an /AS entry for viewing, the view state wins over the default configuration.
+    let on = ocg("On", "/Usage << /View << /ViewState /ON >> >>");
+    let bytes = three_groups([&ocg("Plain", ""), &off, &on], &[], "/OFF [{2}] /AS [<< /Event /View /Category [/View] /OCGs [{1} {2}] >>]");
+    let d = import(&bytes).unwrap();
+    assert_eq!(names(&d), ["Plain", "Off", "On"]);
+    assert_eq!(visibility(&d.layers), [true, false, true]);
+    assert_eq!(colors(&d.layers[1]), [Color::rgb(0.0, 0.0, 1.0)]);
+    assert_eq!(colors(&d.layers[2]), [Color::rgb(0.0, 1.0, 0.0)], "the art the default configuration hides is read");
+    // Without one, a view state that is off still hides the layer.
+    let d = import(&three_groups([&ocg("Plain", ""), &off, &ocg("Other", "")], &[], "")).unwrap();
+    assert_eq!(visibility(&d.layers), [true, false, true]);
+    assert_eq!(colors(&d.layers[1]), [Color::rgb(0.0, 0.0, 1.0)]);
+}
+
+#[test]
+fn nested_groups_become_sublayers_and_hidden_ones_keep_their_art() {
+    // The order as an object of its own (as Illustrator writes it): "Top" holds "Sub", which is
+    // off; a label's groups stay at the level of the label.
+    let order = first_extra(1) + 3;
+    let bytes = three_groups(
+        [&ocg("Top", ""), &ocg("Sub", ""), &ocg("Other", "")],
+        &["[{0} [{1}] [(Label) {2}]]"],
+        &format!("/OFF [{{1}}] /Order {order} 0 R"),
+    );
+    let d = import(&bytes).unwrap();
+    assert_eq!(names(&d), ["Top", "Other"]);
+    assert_eq!(visibility(&d.layers), [true, true]);
+    let top = d.layers[0].children().unwrap();
+    assert_eq!(top.len(), 2, "its art, then its sublayer");
+    assert_eq!(top[0].appearance.fill().and_then(|f| f.paint.color()), Some(Color::rgb(1.0, 0.0, 0.0)));
+    let sub = &top[1];
+    assert!(matches!(sub.kind, NodeKind::Layer { .. }) && sub.name.as_deref() == Some("Sub"));
+    assert!(!sub.visible, "the sublayer that is off is hidden");
+    assert_eq!(colors(sub), [Color::rgb(0.0, 0.0, 1.0)], "with its art");
+    assert_eq!(d.layer_color(sub.id), d.layer_color(d.layers[0].id), "a sublayer takes its layer's colour");
+    assert_eq!(colors(&d.layers[1]), [Color::rgb(0.0, 1.0, 0.0)]);
+}
+
+#[test]
+fn a_sublayer_that_paints_first_brings_its_parent_layer() {
+    // "Sub" paints first; "Top", its parent, paints its own art last.
+    let bytes = three_groups([&ocg("Sub", ""), &ocg("Other", ""), &ocg("Top", "")], &[], "/Order [{2} [{0}] {1}]");
+    let d = import(&bytes).unwrap();
+    assert_eq!(names(&d), ["Top", "Other"]);
+    let top = d.layers[0].children().unwrap();
+    assert_eq!(top.len(), 2);
+    assert_eq!(top[0].name.as_deref(), Some("Sub"));
+    assert_eq!(colors(&top[0]), [Color::rgb(1.0, 0.0, 0.0)]);
+    assert_eq!(top[1].appearance.fill().and_then(|f| f.paint.color()), Some(Color::rgb(0.0, 1.0, 0.0)));
+}
+
+#[test]
+fn hostile_layer_orders_stay_bounded() {
+    // A group listed twice, under itself, and an order nested far deeper than layers go.
+    let deep = format!("{}{{2}}{}", "[".repeat(100), "]".repeat(100));
+    let order = format!("[{{0}} [{{0}} {{1}}] {{1}} [{{0}}] {deep}]");
+    let d = import(&three_groups([&ocg("A", ""), &ocg("B", ""), &ocg("C", "")], &[], &format!("/Order {order}"))).unwrap();
+    assert_eq!(names(&d), ["A", "C"], "C, listed too deep, stays a top-level layer");
+    assert_eq!(d.layers[0].children().unwrap()[1].name.as_deref(), Some("B"));
+    let mut count = 0;
+    d.walk(|n| count += usize::from(matches!(n.kind, NodeKind::Layer { .. })));
+    assert_eq!(count, 3, "each group is one layer");
+}
+
+#[test]
+fn thousands_of_layers_hidden_ones_included_all_come_in() {
+    const N: usize = 3000;
+    let first = first_extra(1);
+    let objs: Vec<String> = (0..N).map(|i| ocg(&format!("L{i}"), "")).collect();
+    let refs: Vec<String> = (0..N).map(|i| format!("{} 0 R", first + i)).collect();
+    let props: String = refs.iter().enumerate().map(|(i, r)| format!("/M{i} {r} ")).collect();
+    let content: String = (0..N).map(|i| format!("/OC /M{i} BDC {} {} 1 1 re f EMC ", i % 100, i / 100)).collect();
+    let off: Vec<&str> = refs.iter().step_by(2).map(String::as_str).collect();
+    let catalog = format!("/OCProperties << /OCGs [{}] /D << /OFF [{}] >> >> ", refs.join(" "), off.join(" "));
+    let page = PdfPage { resources: format!("/Properties << {props}>>"), ..PdfPage::new(100.0, 100.0, &content) };
+    let objs: Vec<&str> = objs.iter().map(String::as_str).collect();
+    let d = import(&pdf_with_catalog(&[page], &objs, &catalog, None)).unwrap();
+    assert_eq!(d.layers.len(), N);
+    assert!(d.layers.iter().enumerate().all(|(i, l)| l.visible == (i % 2 == 1) && l.children().is_some_and(|c| c.len() == 1)));
+}

crates/pdf/src/tests_live_text.rs

@@ -3,11 +3,13 @@
 use krilla::geom::{Point as KPoint, Transform};
 use krilla::page::PageSettings;
 use krilla::text::{Font, TextDirection};
+use kurbo::Shape;
 use vectorcraft_doc::{Document, NodeKind, TextObject};
 
 use crate::*;
 
 const SOURCE_SANS: &[u8] = include_bytes!("../../../assets/fonts/SourceSans3-Regular.ttf");
+const SOURCE_SERIF: &[u8] = include_bytes!("../../../assets/fonts/SourceSerif4-Regular.ttf");
 
 /// A 300 × 200 pt page with `lines` of (x, y from the top, size, text) in Source Sans 3, and the
 /// same rotated 90° when `rotated`.
@@ -157,21 +159,73 @@ fn a_glyph_whose_unicode_names_another_letter_stays_outlined() {
     assert!(r.warnings.iter().any(|w| w.contains("differ from the installed font")), "{:?}", r.warnings);
 }
 
-/// Source Sans 3 renamed `SourceSans9-Regular` (a font no machine has installed).
-fn uninstalled_font() -> Vec<u8> {
-    let mut bytes = SOURCE_SANS.to_vec();
-    let utf16: Vec<u8> = "SourceSans3-Regular".encode_utf16().flat_map(u16::to_be_bytes).collect();
-    let renamed16: Vec<u8> = "SourceSans9-Regular".encode_utf16().flat_map(u16::to_be_bytes).collect();
-    for (from, to) in [(b"SourceSans3-Regular".to_vec(), b"SourceSans9-Regular".to_vec()), (utf16, renamed16)] {
-        let mut i = 0;
-        while let Some(at) = bytes[i..].windows(from.len()).position(|w| w == from.as_slice()) {
-            bytes[i + at..i + at + from.len()].copy_from_slice(&to);
-            i += at + from.len();
+/// `font` with each of `names` (`from`, `to`, the same length) replaced, in ASCII and UTF-16.
+fn renamed(font: &[u8], names: &[(&str, &str)]) -> Vec<u8> {
+    let mut bytes = font.to_vec();
+    let utf16 = |s: &str| s.encode_utf16().flat_map(u16::to_be_bytes).collect::<Vec<u8>>();
+    for &(from, to) in names {
+        assert_eq!(from.len(), to.len());
+        for (from, to) in [(from.as_bytes().to_vec(), to.as_bytes().to_vec()), (utf16(from), utf16(to))] {
+            let mut i = 0;
+            while let Some(at) = bytes[i..].windows(from.len()).position(|w| w == from.as_slice()) {
+                bytes[i + at..i + at + from.len()].copy_from_slice(&to);
+                i += at + from.len();
+            }
         }
     }
     bytes
 }
 
+/// Source Sans 3 renamed `SourceSans9-Regular` (a font no machine has installed).
+fn uninstalled_font() -> Vec<u8> {
+    renamed(SOURCE_SANS, &[("SourceSans3-Regular", "SourceSans9-Regular")])
+}
+
+/// Source Serif 4 renamed `SourceSerif9-Regular`, family Source Serif 9: a serif font that isn't
+/// installed (the fallback font, Source Sans 3, is a sans).
+fn uninstalled_serif() -> Vec<u8> {
+    renamed(SOURCE_SERIF, &[("SourceSerif4", "SourceSerif9"), ("Source Serif 4", "Source Serif 9")])
+}
+
+/// A page with `text` in `font` (24 pt, at 20, 50).
+fn one_line_pdf(font: Vec<u8>, text: &str) -> Vec<u8> {
+    let mut pdf = krilla::Document::new();
+    let mut page = pdf.start_page_with(PageSettings::from_wh(300.0, 200.0).unwrap());
+    let mut s = page.surface();
+    s.draw_text(KPoint::from_xy(20.0, 50.0), Font::new(font.into(), 0).unwrap(), 24.0, text, false, TextDirection::Auto);
+    s.finish();
+    page.finish();
+    pdf.finish().unwrap()
+}
+
+/// The outlines text imported as (`textAs: outlines`), as one path.
+fn outlines(d: &Document) -> kurbo::BezPath {
+    let mut all = kurbo::BezPath::new();
+    d.walk(|n| {
+        if let NodeKind::Path { path, .. } = &n.kind {
+            all.extend(path.to_bezpath().iter());
+        }
+    });
+    all
+}
+
+#[test]
+fn outlined_text_in_a_missing_font_keeps_the_embedded_glyphs() {
+    let outlined = |bytes: &[u8]| {
+        let r = import_with_report(bytes, &ImportOptions { text_as: TextAs::Outlines, ..Default::default() }).unwrap();
+        assert!(texts(&r.document).is_empty());
+        outlines(&r.document)
+    };
+    let missing = outlined(&one_line_pdf(uninstalled_serif(), "Serif Hamburg"));
+    let installed = outlined(&one_line_pdf(SOURCE_SERIF.to_vec(), "Serif Hamburg"));
+    let fallback = outlined(&one_line_pdf(SOURCE_SANS.to_vec(), "Serif Hamburg"));
+    let (m, i, f) = (missing.bounding_box(), installed.bounding_box(), fallback.bounding_box());
+    assert!(m.width() > 50.0, "{m:?}");
+    let near = |a: kurbo::Rect, b: kurbo::Rect| (a.x0 - b.x0).abs() + (a.x1 - b.x1).abs() + (a.y0 - b.y0).abs() + (a.y1 - b.y1).abs() < 0.01;
+    assert!(near(m, i), "the file's own serif glyphs: {m:?} vs {i:?}");
+    assert!(!near(m, f), "not the fallback font's: {m:?} vs {f:?}");
+}
+
 #[test]
 fn text_in_a_missing_font_stays_live_type() {
     for stroke_only in [false, true] {

crates/pdf/src/tests_output.rs

@@ -218,11 +218,12 @@ fn images_are_converted_too() {
     assert!(String::from_utf8_lossy(&plain.bytes).contains("/ColorSpace/DeviceRGB"));
     let r = pdf(&d, json!({"output": {"conversion": "preserveNumbers", "destination": GENERIC_CMYK}}));
     assert!(String::from_utf8_lossy(&r.bytes).contains("/ColorSpace/DeviceCMYK"), "a CMYK image");
-    // CMYK images aren't written as JPEG.
+    // Converted to CMYK and compressed with JPEG: a CMYK JPEG.
     let jpeg =
         pdf(&d, json!({"compression": {"color": {"compression": "jpeg"}}, "output": {"conversion": "destination", "destination": GENERIC_CMYK}}));
-    assert!(!String::from_utf8_lossy(&jpeg.bytes).contains("/DCTDecode"));
-    assert!(jpeg.warnings.iter().any(|w| w.contains("ZIP")), "{:?}", jpeg.warnings);
+    let t = String::from_utf8_lossy(&jpeg.bytes);
+    assert!(t.contains("/DCTDecode") && t.contains("/ColorSpace/DeviceCMYK"), "{t}");
+    assert!(jpeg.warnings.is_empty(), "{:?}", jpeg.warnings);
     // An RGB destination other than sRGB changes the pixels (unless their numbers are kept).
     assert_eq!(first_pixel(&plain.bytes), [200, 40, 30]);
     let p3 = |conversion: &str| first_pixel(&pdf(&d, json!({"output": {"conversion": conversion, "destination": cms::DISPLAY_P3}})).bytes);

crates/render/src/ink.rs

@@ -19,9 +19,11 @@ use std::sync::{Arc, Mutex};
 
 use vectorcraft_color::Color;
 use vectorcraft_color::blend::{cmyk_planes, planes_cmyk};
-use vectorcraft_color::cms::{self, Cms, ProofLut, lab};
-use vectorcraft_doc::{ColorMode, Document};
+use vectorcraft_color::cms::{self, Cms, CmykLut, ProofLut, lab};
+use vectorcraft_doc::cmyk::Inks;
+use vectorcraft_doc::{ColorMode, Document, ImageBlob};
 use vello_cpu::Pixmap;
+use vello_cpu::color::PremulRgba8;
 use vello_cpu::peniko;
 
 use crate::{RenderOptions, Renderer};
@@ -117,56 +119,22 @@ thread_local! {
     static SEPARATED: RefCell<Separated> = RefCell::default();
 }
 
-/// Grid points per ink of [`InkLut`].
-const LUT_N: usize = 17;
-
 /// Inks → display sRGB through the working CMYK profile: a 17⁴ lookup table of XYZ, interpolated
 /// quadrilinearly (inks mix close to linearly in light, and out-of-gamut colours are clipped
 /// after interpolating, not before).
-struct InkLut {
-    data: Vec<[f32; 3]>,
-}
+pub(crate) struct InkLut(CmykLut);
 
 impl InkLut {
     fn build(cms: &Cms) -> Self {
-        let s = (LUT_N - 1) as f32;
-        let mut data = Vec::with_capacity(LUT_N.pow(4));
-        for c in 0..LUT_N {
-            for m in 0..LUT_N {
-                for y in 0..LUT_N {
-                    for k in 0..LUT_N {
-                        data.push(lab::lab_to_xyz(cms.cmyk_to_lab([c, m, y, k].map(|i| i as f32 / s))));
-                    }
-                }
-            }
-        }
-        Self { data }
+        Self(CmykLut::build(|inks| {
+            let [x, y, z] = lab::lab_to_xyz(cms.cmyk_to_lab(inks));
+            [x, y, z, 0.0]
+        }))
     }
 
     fn apply(&self, inks: [f32; 4]) -> [f32; 3] {
-        const STRIDE: [usize; 4] = [LUT_N * LUT_N * LUT_N, LUT_N * LUT_N, LUT_N, 1];
-        let p = inks.map(|v| v.clamp(0.0, 1.0) * (LUT_N - 1) as f32);
-        let i = p.map(|v| (v as usize).min(LUT_N - 2));
-        let base: usize = (0..4).map(|d| i[d] * STRIDE[d]).sum();
-        let mut out = [0.0f32; 3];
-        for corner in 0..16 {
-            let (mut w, mut at) = (1.0f32, base);
-            for d in 0..4 {
-                let t = p[d] - i[d] as f32;
-                if corner >> d & 1 == 1 {
-                    w *= t;
-                    at += STRIDE[d];
-                } else {
-                    w *= 1.0 - t;
-                }
-            }
-            if w > 0.0 {
-                for (o, v) in out.iter_mut().zip(self.data[at]) {
-                    *o += w * v;
-                }
-            }
-        }
-        lab::xyz_to_srgb(out)
+        let [x, y, z, _] = self.0.apply(inks);
+        lab::xyz_to_srgb([x, y, z])
     }
 }
 
@@ -237,9 +205,55 @@ pub(crate) fn amounts(cmy: &[u8], k: &[u8]) -> Vec<u8> {
         .collect()
 }
 
+/// CMYK images as shown, per image key, with the table they were shown through.
+pub(crate) type CmykImages = HashMap<String, (Arc<InkLut>, Arc<Pixmap>)>;
+
+/// Ink amounts `inks` shown through `lut` (opaque).
+fn inks_pixmap(inks: &Inks, lut: &InkLut) -> Option<Pixmap> {
+    let (w, h) = (u16::try_from(inks.width).ok()?, u16::try_from(inks.height).ok()?);
+    // Runs of one colour convert once.
+    let mut last: Option<([u8; 4], PremulRgba8)> = None;
+    let data = inks
+        .data
+        .as_chunks::<4>()
+        .0
+        .iter()
+        .map(|p| match last {
+            Some((k, v)) if k == *p => v,
+            _ => {
+                let [r, g, b] = lut.apply(p.map(|v| v as f32 / 255.0)).map(q);
+                let v = PremulRgba8 { r, g, b, a: 255 };
+                last = Some((*p, v));
+                v
+            }
+        })
+        .collect();
+    Some(Pixmap::from_parts(data, w, h))
+}
+
 impl Renderer {
-    /// Placed image `key` (decoded as `pm`) as painted with `ink`, cached.
-    pub(crate) fn ink_image(&mut self, key: &str, pm: &Arc<Pixmap>, ink: Ink) -> Arc<Pixmap> {
+    /// The pixels of CMYK image `blob` (cached as `cache_key`): its inks shown through the working
+    /// CMYK profile, as CMYK colours are, again when the colour settings change. `None` for
+    /// other images.
+    pub(crate) fn cmyk_image(&mut self, blob: &ImageBlob, cache_key: &str) -> Option<Arc<Pixmap>> {
+        // Other images are cached as they are once decoded: only CMYK ones come here again.
+        let shown = self.cmyk_images.get(cache_key).cloned();
+        if shown.is_none() && !blob.is_cmyk() {
+            return None;
+        }
+        let lut = cached(&DISPLAY, InkLut::build);
+        if let Some((owner, pm)) = shown
+            && Arc::ptr_eq(&owner, &lut)
+        {
+            return Some(pm);
+        }
+        let pm = Arc::new(inks_pixmap(&blob.cmyk()?, &lut)?);
+        self.cmyk_images.insert(cache_key.to_string(), (lut, pm.clone()));
+        Some(pm)
+    }
+
+    /// Placed image `key` (decoded as `pm`, from `blob`) as painted with `ink`, cached.
+    pub(crate) fn ink_image(&mut self, key: &str, pm: &Arc<Pixmap>, ink: Ink, blob: Option<&ImageBlob>) -> Arc<Pixmap> {
         if ink == Ink::Display {
             return pm.clone();
         }
@@ -253,16 +267,27 @@ impl Renderer {
         {
             return planes[at].clone();
         }
-        let planes = [0, 1].map(|i| {
+        // CMYK images paint their own inks; the others are separated.
+        let size = (pm.width() as u32, pm.height() as u32);
+        let inks = blob.filter(|_| self.cmyk_images.contains_key(key)).and_then(ImageBlob::cmyk).filter(|i| (i.width, i.height) == size);
+        let planes = [Ink::Cmy, Ink::K].map(|plane| {
             let mut out = Pixmap::new(pm.width(), pm.height());
+            if let Some(inks) = &inks {
+                for (o, p) in out.data_mut().iter_mut().zip(inks.data.as_chunks::<4>().0) {
+                    let [r, g, b] = plane.plane(p.map(|v| v as f32 / 255.0)).map(q);
+                    *o = PremulRgba8 { r, g, b, a: 255 };
+                }
+                return Arc::new(out);
+            }
+            let lut = &luts[(plane == Ink::K) as usize];
             for (o, s) in out.data_mut().iter_mut().zip(pm.data()) {
                 let a = s.a;
                 if a == 0 {
                     continue;
                 }
                 let un = |v: u8| (v as f32 / a as f32).min(1.0);
-                let [r, g, b] = luts[i].apply([un(s.r), un(s.g), un(s.b)]).map(|v| (v.clamp(0.0, 1.0) * a as f32).round() as u8);
-                *o = vello_cpu::color::PremulRgba8 { r, g, b, a };
+                let [r, g, b] = lut.apply([un(s.r), un(s.g), un(s.b)]).map(|v| (v.clamp(0.0, 1.0) * a as f32).round() as u8);
+                *o = PremulRgba8 { r, g, b, a };
             }
             Arc::new(out)
         });
@@ -293,6 +318,35 @@ mod tests {
         assert!(worst * 255.0 < 2.5, "worst error {} levels", worst * 255.0);
     }
 
+    #[test]
+    fn cmyk_images_show_through_the_profile_and_paint_their_own_inks() {
+        use vectorcraft_color::Paint;
+        use vectorcraft_doc::{Appearance, ImageObject, Node, NodeKind};
+        use vectorcraft_geom::{Affine, Rect, shapes};
+
+        let ink = [0u8, 102, 255, 25];
+        let mut d = Document::new_with_mode(20.0, 10.0, ColorMode::Cmyk);
+        d.images.insert("img".into(), ImageBlob::cmyk_tiff(&Inks::new(2, 2, ink.repeat(4)).unwrap()).unwrap());
+        let l = d.layers[0].id;
+        let im = ImageObject { key: "img".into(), width: 2, height: 2, xf: Affine::scale(5.0), link: None, placement: Default::default() };
+        let n = Node::new(d.alloc_id(), NodeKind::Image(im));
+        d.insert(Some(l), 0, n).unwrap();
+        // The same inks as a fill beside it.
+        let fill = Color::cmyk(0.0, 0.4, 1.0, 25.0 / 255.0);
+        let n =
+            Node::path(d.alloc_id(), shapes::rectangle(Rect::new(10.0, 0.0, 20.0, 10.0)), Appearance::basic(Paint::solid(fill), Paint::None, 0.0));
+        d.insert(Some(l), 1, n).unwrap();
+        let mut r = Renderer::new();
+        let region = Rect::new(0.0, 0.0, 20.0, 10.0);
+        let shown = r.render_region(&d, region, 1.0, true).pixels;
+        let at = |px: &[u8], x: usize| px[(5 * 20 + x) * 4..][..4].to_vec();
+        let (image, fill) = (at(&shown, 5), at(&shown, 15));
+        assert!(image.iter().zip(&fill).all(|(a, b)| a.abs_diff(*b) <= 2), "{image:?} vs {fill:?}");
+        // CMYK exports draw ink amounts: the image's own.
+        let inks = r.render_region_inks(&d, region, 1.0, &RenderOptions::default());
+        assert!(at(&inks, 5).iter().zip(ink).all(|(a, b)| a.abs_diff(b) <= 1), "{:?}", at(&inks, 5));
+    }
+
     #[test]
     fn fixed_colours_and_paper() {
         // White is paper on both planes; the display plane keeps screen colours exactly.

crates/render/src/lib.rs

@@ -325,6 +325,8 @@ pub struct Renderer {
     clip_paints: PtrMap<usize, ClipPaintEntry>,
     /// Placed images as painted in ink planes (see [`ink`]).
     ink_images: ink::InkImages,
+    /// CMYK images as shown through the working CMYK profile (see [`ink`]).
+    cmyk_images: ink::CmykImages,
     /// Gradients along or across strokes, keyed like `strokes` (see [`Self::fill_path_gradient`]).
     stroke_slices: PtrMap<(usize, i32), SliceEntry>,
     /// The keys and sizes of the recoloured images colour adjustments made in `images`, oldest
@@ -407,6 +409,7 @@ impl Renderer {
             clip_paths: vec![],
             clip_paints: PtrMap::default(),
             ink_images: Default::default(),
+            cmyk_images: Default::default(),
             stroke_slices: PtrMap::default(),
             adjusted: Default::default(),
             dim_images: None,
@@ -1320,7 +1323,7 @@ impl Renderer {
         };
         let pixels = if outline && !f.doc.setup.outline_images { None } else { self.image_pixmap(f.doc, &im.key, &cache_key, outline) };
         if let Some(pm) = pixels {
-            let pm = if outline { pm } else { self.ink_image(&cache_key, &pm, f.ink) };
+            let pm = if outline { pm } else { self.ink_image(&cache_key, &pm, f.ink, f.doc.images.get(&im.key)) };
             let sx = im.width as f64 / pm.width().max(1) as f64;
             let sy = im.height as f64 / pm.height().max(1) as f64;
             ctx.set_paint(vello_cpu::Image { image: vello_cpu::ImageSource::Pixmap(pm), sampler: peniko::ImageSampler::default() });
@@ -1398,9 +1401,15 @@ impl Renderer {
         let colour = match self.images.get(cache_key) {
             Some(p) => p.clone(),
             None => {
-                let pm = Arc::new(paint::decode_pixmap(&doc.images.get(key)?.bytes)?);
-                self.images.insert(cache_key.to_string(), pm.clone());
-                pm
+                let blob = doc.images.get(key)?;
+                match self.cmyk_image(blob, cache_key) {
+                    Some(pm) => pm,
+                    None => {
+                        let pm = Arc::new(paint::decode_pixmap(&blob.bytes)?);
+                        self.images.insert(cache_key.to_string(), pm.clone());
+                        pm
+                    }
+                }
             }
         };
         if !grey {

crates/svg/src/css.rs

@@ -10,6 +10,7 @@ use serde::{Deserialize, Serialize};
 use vectorcraft_color::{BlendMode, Color, GradientKind, GradientPaint, Paint};
 use vectorcraft_doc::{AppearanceItem, CharStyle, Document, Justify, LineCap, LiveShape, Node, NodeId, NodeKind, StrokeAlign, StrokeLayer, TextKind};
 use vectorcraft_effects::RasterFx;
+use vectorcraft_geom::shapes::CornerKind;
 use vectorcraft_geom::{Affine, PathData, Point, Rect};
 
 use crate::export::sanitize_id;
@@ -600,7 +601,10 @@ fn corners(path: &PathData, live: Option<&LiveShape>) -> Option<Corners> {
         b.abs() < 1e-9 && c.abs() < 1e-9
     };
     match live {
-        Some(LiveShape::Rectangle { radii, xf, .. }) if upright(xf) => {
+        // CSS rounds corners only: an inverted round or chamfered corner has no border radius.
+        Some(LiveShape::Rectangle { radii, kinds, xf, .. })
+            if upright(xf) && radii.iter().zip(kinds).all(|(r, k)| *r <= 0.0 || *k == CornerKind::Round) =>
+        {
             let [a, _, _, d, _, _] = xf.as_coeffs();
             let s = (a * d).abs().sqrt();
             if radii.iter().all(|r| *r <= 0.0) {

crates/svg/src/export.rs

@@ -198,6 +198,21 @@ fn entity_value(decl: &str) -> String {
     o
 }
 
+/// Image `b` as SVG viewers show it: PNG, JPEG, GIF, WebP and SVG as they are, other formats (a
+/// CMYK TIFF) as PNG.
+fn web_image(b: &ImageBlob) -> std::borrow::Cow<'_, ImageBlob> {
+    use std::borrow::Cow;
+    if matches!(b.mime.as_str(), "image/png" | "image/jpeg" | "image/jpg" | "image/gif" | "image/webp" | "image/svg+xml") {
+        return Cow::Borrowed(b);
+    }
+    let png = image::load_from_memory(&b.bytes).ok().and_then(|img| {
+        let mut out = Vec::new();
+        img.write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).ok()?;
+        Some(out)
+    });
+    png.map_or(Cow::Borrowed(b), |png| Cow::Owned(ImageBlob::png(png)))
+}
+
 /// The usual file extension of an image MIME type.
 fn image_ext(mime: &str) -> &str {
     match mime {
@@ -443,7 +458,7 @@ impl Writer<'_> {
         let (doc, link) = (self.doc, self.opts.images == ImageMode::Link);
         match (im.link.as_ref().filter(|_| link), doc.images.get(&im.key)) {
             (Some(l), _) => Some(l.path.clone()),
-            (None, Some(b)) if !b.bytes.is_empty() => Some(self.blob_href(b)),
+            (None, Some(b)) if !b.bytes.is_empty() => Some(self.blob_href(&web_image(b))),
             _ => im.link.as_ref().map(|l| l.path.clone()),
         }
     }

crates/svg/tests/css_rules.rs

@@ -6,7 +6,8 @@
 
 use vectorcraft_color::{BlendMode, Color, Gradient, GradientGeom, GradientKind, GradientPaint, Paint};
 use vectorcraft_doc::{Appearance, CharStyle, Document, Effect, Justify, LiveShape, Node, NodeId, NodeKind, TextObject};
-use vectorcraft_geom::{Affine, Point, Rect, shapes};
+use vectorcraft_geom::shapes::{self, CornerKind};
+use vectorcraft_geom::{Affine, Point, Rect};
 use vectorcraft_svg::{CssOptions, CssRule, CssUnits, ExportOptions, Styling, css_rules, export};
 
 fn doc() -> Document {
@@ -29,7 +30,7 @@ fn rect(d: &mut Document, (x, y, w, h): (f64, f64, f64, f64), radius: f64) -> No
         Appearance::basic(fill, Paint::solid(Color::rgb8(0, 0, 255)), 2.0),
     );
     if let NodeKind::Path { live, .. } = &mut n.kind {
-        *live = Some(LiveShape::Rectangle { w, h, radii: [radius; 4], xf: Affine::translate((x, y)) });
+        *live = Some(LiveShape::Rectangle { w, h, radii: [radius; 4], kinds: Default::default(), xf: Affine::translate((x, y)) });
     }
     n
 }
@@ -69,6 +70,22 @@ fn rectangle_gives_background_border_and_radius() {
     );
 }
 
+#[test]
+fn live_corners_give_per_corner_radii_and_only_round_ones() {
+    let mut d = doc();
+    let mut n = rect(&mut d, (0.0, 0.0, 100.0, 50.0), 0.0);
+    if let NodeKind::Path { live: Some(LiveShape::Rectangle { radii, kinds, .. }), .. } = &mut n.kind {
+        *radii = [0.0, 8.0, 0.0, 4.0];
+        kinds[0] = CornerKind::Chamfer;
+    }
+    let id = add(&mut d, n);
+    assert_eq!(prop(&one(&d, id, &CssOptions::default()), "border-radius"), Some("0 8px 0 4px"), "a square corner's kind doesn't matter");
+    if let Some(NodeKind::Path { live: Some(LiveShape::Rectangle { kinds, .. }), .. }) = d.node_mut(id).map(|n| &mut n.kind) {
+        kinds[1] = CornerKind::InvertedRound;
+    }
+    assert!(prop(&one(&d, id, &CssOptions::default()), "border-radius").is_none(), "CSS can't cut a corner in");
+}
+
 #[test]
 fn ellipses_round_fully_and_options_change_units_and_names() {
     let mut d = doc();

crates/svg/tests/options.rs

@@ -1,5 +1,5 @@
 //! SVG Options across each other: every styling, id mode and tspan mode reads back, and linked
-//! images are named after their bytes.
+//! images are named after their bytes (and are formats browsers show).
 // Integration tests: unwrapping and panicking on failure is fine here, unlike in shipped code (AGENTS.md › Robustness).
 #![allow(clippy::unwrap_used, clippy::expect_used, clippy::panic)]
 
@@ -73,3 +73,14 @@ fn linked_images_are_named_after_their_bytes() {
     // The same bytes under another key are the same file.
     assert_eq!(export_full(&image_doc("other", vec![1, 2, 3]), &link, None).linked[0].name, a.linked[0].name);
 }
+
+#[test]
+fn cmyk_tiffs_are_written_as_png() {
+    let inks = vectorcraft_doc::cmyk::Inks::new(2, 2, [0u8, 0, 0, 0].repeat(4)).unwrap();
+    let mut d = image_doc("cmyk", vec![]);
+    d.images.insert("cmyk".into(), ImageBlob::cmyk_tiff(&inks).unwrap());
+    // Browsers don't show TIFF: embedded and linked images are PNG.
+    assert!(export(&d, &ExportOptions::default()).contains("href=\"data:image/png;base64,"));
+    let linked = export_full(&d, &ExportOptions { images: ImageMode::Link, ..Default::default() }, None);
+    assert!(linked.linked[0].name.ends_with(".png"), "{}", linked.linked[0].name);
+}

crates/text/src/fontdb.rs

@@ -77,6 +77,8 @@ pub struct FontFace {
     location: Location,
     /// [`Self::variations`] for the shaper (advances, kerning, feature variations).
     pub(crate) instance: Option<harfrust::ShaperInstance>,
+    /// [`Self::ideographic_centre`], read once: layout asks for it per glyph.
+    ideographic_centre: std::sync::OnceLock<f64>,
 }
 
 impl std::fmt::Debug for FontFace {
@@ -170,8 +172,10 @@ impl FontFace {
     /// vertical metrics (an ideograph's cell), else the usual 0.38 (the box running from 0.12 em
     /// below the baseline to 0.88 em above it).
     pub fn ideographic_centre(&self) -> f64 {
-        let gid = ['国', 'あ', '一'].into_iter().map(|c| self.glyph_for(c)).find(|g| *g != 0);
-        gid.and_then(|g| self.vertical_glyph(g)).map_or(0.38, |(advance, origin)| (origin - advance * 0.5) / self.upem)
+        *self.ideographic_centre.get_or_init(|| {
+            let gid = ['国', 'あ', '一'].into_iter().map(|c| self.glyph_for(c)).find(|g| *g != 0);
+            gid.and_then(|g| self.vertical_glyph(g)).map_or(0.38, |(advance, origin)| (origin - advance * 0.5) / self.upem)
+        })
     }
     /// Glyph id for `c` (0 = .notdef).
     pub fn glyph_for(&self, c: char) -> u32 {
@@ -813,6 +817,7 @@ fn make_face(bytes: FontBytes, index: u32, spec: FaceStyle, path: Option<std::pa
         bytes,
         index,
         path,
+        ideographic_centre: std::sync::OnceLock::new(),
     })
 }
 

crates/text/src/layout.rs

@@ -4,7 +4,7 @@ use std::ops::Range;
 
 use kurbo::{Affine, BezPath, ParamCurve, ParamCurveArclen, PathEl, PathSeg, Point, Rect, Shape, Vec2};
 use unicode_bidi::{BidiInfo, Level};
-use vectorcraft_doc::{CharStyle, Justify, Mojikumi, ParaDirection, ParaStyle, PathEffect, TextKind, TextObject};
+use vectorcraft_doc::{CharStyle, Justify, LeadingModel, Mojikumi, ParaDirection, ParaStyle, PathEffect, TextKind, TextObject};
 
 use crate::composer::{Breakpoint, compose};
 use crate::fontdb::FontDb;
@@ -581,11 +581,14 @@ struct Metrics {
     lead: f64,
     cap: f64,
     xh: f64,
+    /// Height of the top of the ideographic em box above the baseline.
+    top: f64,
 }
 
 impl Metrics {
     fn of(g: &SGlyph) -> Self {
-        Self { asc: g.ascent, desc: g.descent, lead: g.leading, cap: g.cap, xh: g.xh }
+        let em = g.face.units_per_em() * g.sy;
+        Self { asc: g.ascent, desc: g.descent, lead: g.leading, cap: g.cap, xh: g.xh, top: (g.face.ideographic_centre() + 0.5) * em }
     }
     fn max(g: &[SGlyph]) -> Option<Self> {
         let mut it = g.iter();
@@ -596,6 +599,7 @@ impl Metrics {
             lead: m.lead.max(g.leading),
             cap: m.cap.max(g.cap),
             xh: m.xh.max(g.xh),
+            top: m.top.max(Self::of(g).top),
         }))
     }
     /// Distance from the frame top to the first baseline.
@@ -622,6 +626,9 @@ struct Pen<'r> {
     fb_min: f64,
     /// Further spans at the current baseline (text wrapping on both sides of an object).
     queued: Vec<(f64, f64, f64)>,
+    /// Leading measured from em box top to em box top: where the next line's em box top goes.
+    model: LeadingModel,
+    next_top: Option<f64>,
 }
 
 impl Pen<'_> {
@@ -630,7 +637,7 @@ impl Pen<'_> {
     /// The `bool` is true for a further span at the previous line's baseline.
     fn place(&mut self, est: Metrics, ind_l: f64, ind_r: f64) -> Option<(f64, f64, f64, bool)> {
         let Some(regions) = self.regions else {
-            let b = self.prev.map_or(0.0, |b| b + est.lead + self.pending);
+            let b = self.prev.map_or(0.0, |b| self.next_baseline(b, est));
             return Some((b, f64::NEG_INFINITY, f64::INFINITY, false));
         };
         if !self.queued.is_empty() {
@@ -640,8 +647,9 @@ impl Pen<'_> {
         loop {
             let r = regions.get(self.ri)?;
             let mut baseline = match self.prev {
+                None if self.model == LeadingModel::EmBoxTop => r.top() + est.top.max(self.fb_min),
                 None => r.top() + est.first_baseline(self.fb, self.fb_min),
-                Some(b) => b + est.lead + self.pending,
+                Some(b) => self.next_baseline(b, est),
             };
             loop {
                 if baseline + est.desc > r.bottom() + 0.01 {
@@ -675,6 +683,18 @@ impl Pen<'_> {
     fn bottom(&self) -> f64 {
         self.regions.and_then(|r| r.get(self.ri)).map_or(f64::INFINITY, |r| r.bottom())
     }
+    /// The baseline of the line after the one at `prev`, for a line of metrics `est`.
+    fn next_baseline(&self, prev: f64, est: Metrics) -> f64 {
+        match (self.model, self.next_top) {
+            (LeadingModel::EmBoxTop, Some(top)) => top + est.top + self.pending,
+            _ => prev + est.lead + self.pending,
+        }
+    }
+    /// A line was set at `baseline` with metrics `m`: where the next one goes from.
+    fn settled(&mut self, baseline: f64, m: Metrics) {
+        self.prev = Some(baseline);
+        self.next_top = Some(baseline - m.top + m.lead);
+    }
 }
 
 /// Advance of a tab at pen position `x`: up to the next stop after it (explicit stops first, then
@@ -873,7 +893,7 @@ fn compose_para(cx: &Ctx<'_>, sg: &[SGlyph], para: &ParaStyle, pen: &Pen<'_>) ->
         let w = x1 - x0 - ind_l - para.right_indent;
         widths.push(w);
         acc += w.max(1.0);
-        sim.prev = Some(b);
+        sim.settled(b, m);
         sim.pending = 0.0;
         if acc > total * 1.6 + 4.0 * w.max(1.0) {
             break;
@@ -887,7 +907,17 @@ fn compose_para(cx: &Ctx<'_>, sg: &[SGlyph], para: &ParaStyle, pen: &Pen<'_>) ->
 }
 
 fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Option<&[Region]>) {
-    let mut pen = Pen { regions, ri: 0, prev: None, pending: 0.0, fb: cx.opts.first_baseline, fb_min: cx.opts.first_baseline_min, queued: vec![] };
+    let mut pen = Pen {
+        regions,
+        ri: 0,
+        prev: None,
+        pending: 0.0,
+        fb: cx.opts.first_baseline,
+        fb_min: cx.opts.first_baseline_min,
+        queued: vec![],
+        model: para.leading_model,
+        next_top: None,
+    };
     'paras: for (pi, pr) in paras.iter().enumerate() {
         let text = cx.text;
         let bidi = para_bidi(text.get(pr.clone()).unwrap_or_default(), para.direction);
@@ -899,8 +929,10 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
         let wakan = if para.mojikumi == Mojikumi::LineEndHalf { space_japanese_and_latin(&mut sg) } else { vec![] };
         let pm = {
             let (asc, desc, lead) = style_metrics(cx.db, cx.style_at(pr.start));
-            let (cap, xh) = cap_x_heights(cx.db, cx.style_at(pr.start));
-            Metrics { asc, desc, lead, cap, xh }
+            let st = cx.style_at(pr.start);
+            let (cap, xh) = cap_x_heights(cx.db, st);
+            let centre = cx.db.face(&st.font_family, &st.font_style).map_or(EM_CENTER, |f| f.ideographic_centre());
+            Metrics { asc, desc, lead, cap, xh, top: (centre + 0.5) * st.size * st.v_scale / 100.0 }
         };
         if pi > 0 {
             pen.pending += para.space_before;
@@ -930,6 +962,10 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
                 let m = Metrics::max(&sg[i..end]).unwrap_or(pm);
                 baseline += if same_baseline || (pen.regions.is_none() && first_in_region) {
                     0.0
+                } else if pen.model == LeadingModel::EmBoxTop {
+                    // The em box top is fixed (the frame's top, or the line above's): the baseline
+                    // hangs from it by this line's tallest em box.
+                    if first_in_region { m.top.max(pen.fb_min) - est.top.max(pen.fb_min) } else { m.top - est.top }
                 } else if first_in_region {
                     m.first_baseline(pen.fb, pen.fb_min) - est.first_baseline(pen.fb, pen.fb_min)
                 } else {
@@ -1077,7 +1113,7 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
                 glyph_end: cx.out.glyphs.len(),
                 avail: if regions.is_some() { (ax0, ax1) } else { (start_x, x_end) },
             });
-            pen.prev = Some(baseline);
+            pen.settled(baseline, m);
             // Further spans of this line band share the settled baseline.
             for q in &mut pen.queued {
                 q.0 = baseline;

crates/text/src/tests.rs

@@ -522,3 +522,38 @@ fn justified_japanese_lines_spread_between_characters() {
     assert!(solid(at) && solid(at + 1), "A–B–C set solid");
     assert!(g[at].origin.x - g[at - 1].origin.x > a + 0.1, "二–A takes its share");
 }
+
+/// Leading measured from em box top to em box top (Japanese layout's model): area type's first line
+/// touches the frame's top; lines of one size are as far apart as with baseline-to-baseline leading;
+/// with sizes mixed, a line's leading is the space below it (baseline leading: above it).
+#[test]
+fn em_box_top_leading_hangs_lines_from_the_line_above() {
+    use vectorcraft_doc::{LeadingModel, TextRun};
+    let st = |size: f64| CharStyle { size, leading: Some(size * 1.5), ..style(size) };
+    let lay = |t: &TextObject, m: LeadingModel| {
+        let mut t = t.clone();
+        t.para.leading_model = m;
+        layout(db(), &t)
+    };
+    // The em box top: 0.88 em above the baseline (fonts without vertical metrics).
+    let top = |size: f64| 0.88 * size;
+    let one_size = area("一行目\n二行目\n三行目", st(20.0), Rect::new(0.0, 0.0, 300.0, 300.0), Justify::Left);
+    let (roman, em) = (lay(&one_size, LeadingModel::RomanBaseline), lay(&one_size, LeadingModel::EmBoxTop));
+    assert!((em.lines[0].baseline - top(20.0)).abs() < 0.01, "the first line's em box touches the top: {}", em.lines[0].baseline);
+    assert!((roman.lines[0].baseline - em.lines[0].baseline).abs() > 0.5, "baseline leading keeps Area Type Options' first baseline");
+    for l in [&roman, &em] {
+        assert!((l.lines[1].baseline - l.lines[0].baseline - 30.0).abs() < 0.01 && (l.lines[2].baseline - l.lines[1].baseline - 30.0).abs() < 0.01);
+    }
+    // 40 pt over 20 pt (leading 60 and 30).
+    let mut mixed = point("", st(40.0));
+    mixed.runs = vec![TextRun { text: "大\n".into(), style: st(40.0) }, TextRun { text: "小".into(), style: st(20.0) }];
+    let roman = lay(&mixed, LeadingModel::RomanBaseline);
+    assert!((roman.lines[1].baseline - roman.lines[0].baseline - 30.0).abs() < 0.01, "the small line's leading, above it");
+    let em = lay(&mixed, LeadingModel::EmBoxTop);
+    let want = -top(40.0) + 60.0 + top(20.0);
+    assert!(
+        (em.lines[1].baseline - em.lines[0].baseline - want).abs() < 0.01,
+        "the big line's leading, below it: {} vs {want}",
+        em.lines[1].baseline - em.lines[0].baseline
+    );
+}

crates/tools/src/builder.rs

@@ -1,7 +1,8 @@
 //! Shape Builder (Shift+M), Live Paint Bucket (K) and Live Paint Selection (Shift+L).
 //!
 //! The tools only emit commands (`shapeBuilder.merge`, `livePaint.fill`, `livePaint.strokeEdge`,
-//! `select.*`); the planar arrangement comes from `vectorcraft_pathops::regions`.
+//! `select.*`); the planar arrangement comes from `vectorcraft_pathops::shape_builder` (Shape
+//! Builder) and `vectorcraft_pathops::live_paint` (Live Paint).
 //!
 //! **Live Paint groups** are ordinary groups (no special node kind): the group's name starts with
 //! [`LIVE_PAINT_PREFIX`]; its first child is a hidden group named [`SOURCES_NAME`] holding the
@@ -151,6 +152,141 @@ pub fn shapes_for<'a>(doc: &'a Document, roots: &[NodeId]) -> (Vec<po::Shape>, V
     (shapes, used)
 }
 
+/// Shape Builder inputs: [`shapes_for`], with the open subpaths of filled paths closed where that
+/// encloses an area (the fill bounds a region, as if an invisible edge closed it). Unfilled open
+/// paths and straight lines stay open and cut the regions they cross.
+fn shape_builder_shapes<'a>(doc: &'a Document, roots: &[NodeId]) -> (Vec<po::Shape>, Vec<&'a Node>) {
+    let (mut shapes, leaves) = shapes_for(doc, roots);
+    for (s, l) in shapes.iter_mut().zip(&leaves) {
+        if l.appearance.fill_paint().is_none() {
+            continue;
+        }
+        for sp in s.path.subpaths.iter_mut().filter(|sp| !sp.closed) {
+            let mut closed = sp.clone();
+            closed.closed = true;
+            let mut bp = BezPath::new();
+            closed.to_bezpath_into(&mut bp);
+            let size = bp.bounding_box().size();
+            sp.closed = bp.area().abs() > 1e-9 * (size.width * size.width + size.height * size.height);
+        }
+    }
+    (shapes, leaves)
+}
+
+/// A planar-map face with its outline and bounds, ready for hit tests.
+pub type Face = (po::Region, BezPath, Rect);
+
+fn faces_of(regions: Vec<po::Region>) -> Vec<Face> {
+    regions
+        .into_iter()
+        .filter_map(|r| {
+            let bp = r.path.to_bezpath();
+            let b = r.path.bounds()?;
+            Some((r, bp, b))
+        })
+        .collect()
+}
+
+/// The Shape Builder's planar map of a selection.
+#[derive(Default)]
+pub struct BuilderMap {
+    /// The inputs, back → front (see [`po::shape_builder`]).
+    pub shapes: Vec<po::Shape>,
+    pub regions: Vec<Face>,
+    /// Pieces of the unfilled open paths, keyed by input index, with their bounds.
+    pub lines: Vec<(po::Shape, Rect)>,
+}
+
+/// What a Shape Builder gesture touches at a point.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Hit {
+    Region(usize),
+    Line(usize),
+}
+
+impl BuilderMap {
+    /// The map of `roots` (sorted back → front), with the leaves the inputs came from.
+    pub fn new<'a>(doc: &'a Document, roots: &[NodeId]) -> (Self, Vec<&'a Node>) {
+        let (shapes, leaves) = shape_builder_shapes(doc, roots);
+        if shapes.is_empty() {
+            return (Self::default(), leaves);
+        }
+        let (regions, lines) = po::shape_builder(&shapes);
+        let lines = lines.into_iter().filter_map(|l| Some((l.path.bounds()?, l))).map(|(b, l)| (l, b)).collect();
+        (Self { shapes, regions: faces_of(regions), lines }, leaves)
+    }
+
+    /// The region containing `p`.
+    pub fn region_at(&self, p: Point) -> Option<usize> {
+        self.regions.iter().position(|(_, bp, b)| b.contains(p) && bp.winding(p) != 0)
+    }
+
+    /// The line piece nearest `p`, within `tol`.
+    pub fn line_near(&self, p: Point, tol: f64) -> Option<usize> {
+        let mut best: Option<(f64, usize)> = None;
+        for (i, (l, b)) in self.lines.iter().enumerate() {
+            if b.inflate(tol, tol).contains(p)
+                && let Some((.., d)) = l.path.nearest(p)
+                && d <= tol
+                && best.is_none_or(|b| d < b.0)
+            {
+                best = Some((d, i));
+            }
+        }
+        best.map(|b| b.1)
+    }
+
+    /// What a gesture at `p` touches: with `line_tol` (erasing), a line piece that close, else the
+    /// region under it.
+    pub fn hit(&self, p: Point, line_tol: Option<f64>) -> Option<Hit> {
+        line_tol.and_then(|t| self.line_near(p, t)).map(Hit::Line).or_else(|| self.region_at(p).map(Hit::Region))
+    }
+
+    /// Does line piece `i` run between two of `regions` (an edge that merging or deleting them
+    /// removes)?
+    pub fn line_between(&self, i: usize, regions: &[usize]) -> bool {
+        let Some(sp) = self.lines.get(i).and_then(|(l, _)| l.path.subpaths.first()) else { return false };
+        let n = sp.segment_count();
+        if n == 0 {
+            return false;
+        }
+        let c = sp.segment(n / 2);
+        use kurbo::{ParamCurve as _, ParamCurveDeriv as _};
+        let (m, d) = (c.eval(0.5), c.deriv().eval(0.5).to_vec2());
+        let len = d.hypot();
+        if !(len.is_finite() && len > 0.0) {
+            return false;
+        }
+        // A little to each side: inside the faces next to it, which share it exactly.
+        let off = d.turn_90() * (0.05f64.min(0.05 * c.p0.distance(c.p3)).max(1e-6) / len);
+        [m + off, m - off].into_iter().all(|q| self.region_at(q).is_some_and(|r| regions.contains(&r)))
+    }
+}
+
+/// The regions and line pieces a Shape Builder gesture has touched, in the order touched.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Touched {
+    pub regions: Vec<usize>,
+    pub lines: Vec<usize>,
+}
+
+impl Touched {
+    pub fn add(&mut self, hit: Option<Hit>) {
+        let (list, i) = match hit {
+            Some(Hit::Region(i)) => (&mut self.regions, i),
+            Some(Hit::Line(i)) => (&mut self.lines, i),
+            None => return,
+        };
+        if !list.contains(&i) {
+            list.push(i);
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.regions.is_empty() && self.lines.is_empty()
+    }
+}
+
 /// Selected roots sorted back → front in document order.
 pub fn sorted_roots(doc: &Document, ids: &[NodeId]) -> Vec<NodeId> {
     let mut v: Vec<(Vec<usize>, NodeId)> = ids.iter().filter_map(|id| doc.index_path(*id).map(|p| (p, *id))).collect();
@@ -238,13 +374,12 @@ pub fn hatch(path: &BezPath, gap: f64) -> BezPath {
     out
 }
 
-/// Regions of the current selection, cached by document identity and selection.
+/// The planar map of the current selection, cached by document identity and selection.
 #[derive(Default)]
 struct RegionCache {
     key: Option<(usize, Vec<NodeId>)>,
-    regions: Vec<(po::Region, BezPath, Rect)>,
-    /// Live Paint faces (every path an edge, open ones included) rather than Shape Builder
-    /// regions (the filled areas of the shapes).
+    map: BuilderMap,
+    /// Live Paint faces (every path an edge, filled or not) rather than Shape Builder regions.
     live: bool,
 }
 
@@ -252,58 +387,57 @@ impl RegionCache {
     fn live_paint() -> Self {
         Self { live: true, ..Default::default() }
     }
-    fn get(&mut self, cx: &ToolContext) -> &[(po::Region, BezPath, Rect)] {
+    fn get(&mut self, cx: &ToolContext) -> &BuilderMap {
         let key = (cx.doc as *const Document as usize, cx.selection.objects.clone());
         if self.key.as_ref() != Some(&key) {
             let roots = sorted_roots(cx.doc, &cx.selection.objects);
-            let (shapes, _) = shapes_for(cx.doc, &roots);
-            self.regions = if shapes.is_empty() {
-                vec![]
+            self.map = if self.live {
+                let (shapes, _) = shapes_for(cx.doc, &roots);
+                let regions = if shapes.is_empty() { vec![] } else { faces_of(po::live_paint(&shapes).0) };
+                BuilderMap { regions, ..Default::default() }
             } else {
-                let regions = if self.live { po::live_paint(&shapes).0 } else { po::regions(&shapes) };
-                regions
-                    .into_iter()
-                    .filter_map(|r| {
-                        let bp = r.path.to_bezpath();
-                        let b = r.path.bounds()?;
-                        Some((r, bp, b))
-                    })
-                    .collect()
+                BuilderMap::new(cx.doc, &roots).0
             };
             self.key = Some(key);
         }
-        &self.regions
+        &self.map
     }
     fn at(&mut self, cx: &ToolContext, p: Point) -> Option<usize> {
-        self.get(cx).iter().position(|(_, bp, b)| b.contains(p) && bp.winding(p) != 0)
+        self.get(cx).region_at(p)
     }
 }
 
 // ---------- Shape Builder ----------
 
-/// Shape Builder tool: drag across regions to merge them, Alt-drag to delete them.
+/// Shape Builder tool: drag across regions to merge them, Alt-drag to delete them (and the pieces
+/// of open paths it passes over).
 #[derive(Default)]
 pub struct ShapeBuilderTool {
     cache: RegionCache,
-    hover: Option<usize>,
+    hover: Option<Hit>,
     points: Vec<Point>,
-    touched: Vec<usize>,
+    touched: Touched,
     dragging: bool,
     alt: bool,
 }
 
+/// How close (screen px) the pointer must come to a line piece to delete it.
+const LINE_TOL_PX: f64 = 4.0;
+
 impl ShapeBuilderTool {
+    fn line_tol(cx: &ToolContext, alt: bool) -> Option<f64> {
+        alt.then(|| cx.tol(LINE_TOL_PX))
+    }
+
     fn touch(&mut self, cx: &ToolContext, from: Option<Point>, to: Point) {
         let pts = match from {
             Some(a) => sample_polyline(&[a, to], cx.tol(2.0)),
             None => vec![to],
         };
+        let tol = Self::line_tol(cx, self.alt);
         for p in pts {
-            if let Some(i) = self.cache.at(cx, p)
-                && !self.touched.contains(&i)
-            {
-                self.touched.push(i);
-            }
+            let hit = self.cache.get(cx).hit(p, tol);
+            self.touched.add(hit);
         }
     }
 }
@@ -317,7 +451,7 @@ impl Tool for ShapeBuilderTool {
         let p = ev.pos;
         match ev.kind {
             PointerKind::Move => {
-                self.hover = self.cache.at(cx, p);
+                self.hover = self.cache.get(cx).hit(p, Self::line_tol(cx, ev.mods.alt));
                 vec![]
             }
             PointerKind::Down => {
@@ -327,7 +461,7 @@ impl Tool for ShapeBuilderTool {
                 self.dragging = true;
                 self.alt = ev.mods.alt;
                 self.points = vec![p];
-                self.touched.clear();
+                self.touched = Touched::default();
                 self.touch(cx, None, p);
                 vec![]
             }
@@ -353,7 +487,12 @@ impl Tool for ShapeBuilderTool {
                 self.cache.key = None;
                 let roots = sorted_roots(cx.doc, &cx.selection.objects);
                 let pts: Vec<Value> = points.iter().map(|q| json!([q.x, q.y])).collect();
-                vec![Action::Exec("shapeBuilder.merge".into(), json!({ "ids": json_ids(&roots), "points": pts, "erase": self.alt || ev.mods.alt }))]
+                let erase = self.alt || ev.mods.alt;
+                let mut params = json!({ "ids": json_ids(&roots), "points": pts, "erase": erase });
+                if let Some(t) = Self::line_tol(cx, erase) {
+                    params["tolerance"] = json!(t);
+                }
+                vec![Action::Exec("shapeBuilder.merge".into(), params)]
             }
             _ => vec![],
         }
@@ -361,13 +500,26 @@ impl Tool for ShapeBuilderTool {
 
     fn overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
         let mut out = vec![];
-        let regions = &self.cache.regions;
+        let map = &self.cache.map;
         let color = if self.dragging && self.alt { HIGHLIGHT_RED } else { HATCH };
-        let show: Vec<usize> = if self.dragging { self.touched.clone() } else { self.hover.into_iter().collect() };
-        for i in show {
-            if let Some((_, bp, _)) = regions.get(i) {
-                out.push(Overlay::Path { path: hatch(bp, cx.tol(4.0)), color, width: 1.0, dashed: false });
-                out.push(Overlay::Path { path: bp.clone(), color, width: 1.0, dashed: false });
+        let show: Vec<Hit> = if self.dragging {
+            self.touched.regions.iter().map(|&i| Hit::Region(i)).chain(self.touched.lines.iter().map(|&i| Hit::Line(i))).collect()
+        } else {
+            self.hover.into_iter().collect()
+        };
+        for hit in show {
+            match hit {
+                Hit::Region(i) => {
+                    if let Some((_, bp, _)) = map.regions.get(i) {
+                        out.push(Overlay::Path { path: hatch(bp, cx.tol(4.0)), color, width: 1.0, dashed: false });
+                        out.push(Overlay::Path { path: bp.clone(), color, width: 1.0, dashed: false });
+                    }
+                }
+                Hit::Line(i) => {
+                    if let Some((l, _)) = map.lines.get(i) {
+                        out.push(Overlay::Path { path: l.path.to_bezpath(), color: HIGHLIGHT_RED, width: 3.0, dashed: false });
+                    }
+                }
             }
         }
         if self.dragging && self.points.len() > 1 {
@@ -434,6 +586,7 @@ fn lp_overlays(h: &LpHover, cache: &RegionCache) -> Vec<Overlay> {
         LpHover::None => vec![],
         LpHover::Part(bp) => vec![Overlay::Path { path: bp.clone(), color: HIGHLIGHT_RED, width: 4.0, dashed: false }],
         LpHover::Region(i) => cache
+            .map
             .regions
             .get(*i)
             .map(|(_, bp, _)| vec![Overlay::Path { path: bp.clone(), color: HIGHLIGHT_RED, width: 4.0, dashed: false }])
@@ -623,7 +776,7 @@ mod tests {
         let mut t = ShapeBuilderTool::default();
         t.pointer(&cx, &ev(PointerKind::Down, 25.0, 50.0));
         t.pointer(&cx, &ev(PointerKind::Drag, 75.0, 50.0));
-        assert_eq!(t.touched.len(), 2);
+        assert_eq!(t.touched.regions.len(), 2);
         assert!(t.busy());
         let acts = t.pointer(&cx, &ev(PointerKind::Up, 75.0, 50.0));
         let Action::Exec(id, v) = &acts[0] else { panic!("{acts:?}") };

crates/tools/src/corners.rs

@@ -1,12 +1,19 @@
-//! Live Corners: the widgets inside each corner of a selected live rectangle. Dragging one rounds
-//! (or sharpens) all four corners together. The Selection and Direct Selection tools share this,
-//! and the canvas draws the widgets from the same geometry.
+//! Live Corners: the widgets inside the corners of a selected live rectangle. Dragging one rounds
+//! (or sharpens) the corners whose widgets show together: all four when the whole shape is
+//! selected, those with a selected anchor when Direct Selection picked some. Alt-clicking a widget
+//! cycles their corner kind (round, inverted round, chamfer); double-clicking one opens the
+//! Corners dialog. The Selection and Direct Selection tools share this, and the canvas draws the
+//! widgets from the same geometry.
 
-use serde_json::json;
+use serde_json::{Map, Value, json};
 use vectorcraft_doc::{Document, LiveShape, NodeId, NodeKind, Selection};
+use vectorcraft_geom::shapes::CornerKind;
 use vectorcraft_geom::{Affine, Point, Vec2};
 
-use crate::{Action, Overlay, ToolContext};
+use crate::{Action, Overlay, PointerEvent, ToolContext};
+
+/// The dialog a double-click on a corner widget opens: `{id, corners}`.
+pub const DIALOG: &str = "corners";
 
 /// Widgets sit at least this far inside their corner (screen px), further in once the radius is.
 const MIN_INSET_PX: f64 = 10.0;
@@ -24,9 +31,12 @@ pub struct CornerWidgets {
     w: f64,
     h: f64,
     radii: [f64; 4],
+    kinds: [CornerKind; 4],
     xf: Affine,
     /// Widget centres in document coordinates, in radii order.
     pub points: [Point; 4],
+    /// The corners whose widgets show (and which a drag edits).
+    pub shown: [bool; 4],
 }
 
 impl CornerWidgets {
@@ -36,10 +46,9 @@ impl CornerWidgets {
         if !doc.is_editable(id) {
             return None;
         }
-        let Some(NodeKind::Path { live: Some(LiveShape::Rectangle { w, h, radii, xf }), .. }) = doc.node(id).map(|n| &n.kind) else {
-            return None;
-        };
-        let (w, h, radii, xf) = (*w, *h, *radii, *xf);
+        let Some(NodeKind::Path { live: Some(live), .. }) = doc.node(id).map(|n| &n.kind) else { return None };
+        let LiveShape::Rectangle { w, h, radii, kinds, xf } = live else { return None };
+        let (w, h, radii, kinds, xf) = (*w, *h, *radii, *kinds, *xf);
         // Screen pixels per shape unit along each side (the shape may be scaled or skewed).
         let c = xf.as_coeffs();
         let (px, py) = (Vec2::new(c[0], c[1]).hypot() * zoom, Vec2::new(c[2], c[3]).hypot() * zoom);
@@ -52,7 +61,7 @@ impl CornerWidgets {
             let iy = radii[k].max(MIN_INSET_PX / py).min(h / 2.0);
             xf * Point::new(fx * w + sx * ix, fy * h + sy * iy)
         });
-        Some(Self { id, w, h, radii, xf, points })
+        Some(Self { id, w, h, radii, kinds, xf, points, shown: live.picked_corners(selection.partial(id)) })
     }
 
     /// The widgets the active tool can drag (View → Show Corner Widget on).
@@ -63,9 +72,32 @@ impl CornerWidgets {
         Self::of(cx.doc, cx.selection, cx.zoom)
     }
 
-    /// Index of the widget nearest to `p` within `tol` (document units).
+    /// The centres of the widgets that show.
+    pub fn visible(&self) -> impl Iterator<Item = Point> + '_ {
+        self.points.iter().zip(self.shown).filter(|(_, on)| *on).map(|(p, _)| *p)
+    }
+
+    /// The indices of the shown corners.
+    fn shown_indices(&self) -> Value {
+        (0..4).filter(|k| self.shown[*k]).collect()
+    }
+
+    /// Index of the shown widget nearest to `p` within `tol` (document units).
     pub fn hit(&self, p: Point, tol: f64) -> Option<usize> {
-        (0..4).filter(|k| self.points[*k].distance(p) <= tol).min_by(|a, b| self.points[*a].distance(p).total_cmp(&self.points[*b].distance(p)))
+        let d = |k: &usize| self.points[*k].distance(p);
+        (0..4).filter(|k| self.shown[*k] && d(k) <= tol).min_by(|a, b| d(a).total_cmp(&d(b)))
+    }
+
+    /// `object.setLiveShape` params setting `key` on the shown corners (all four unless some are
+    /// hidden, which `corners` then leaves out).
+    fn command(&self, key: &str, value: Value) -> Value {
+        let mut p = Map::new();
+        p.insert("id".into(), json!(self.id.0));
+        p.insert(key.into(), value);
+        if self.shown != [true; 4] {
+            p.insert("corners".into(), self.shown_indices());
+        }
+        Value::Object(p)
     }
 }
 
@@ -74,23 +106,32 @@ pub fn over_widget(cx: &ToolContext, p: Point) -> bool {
     CornerWidgets::for_tool(cx).and_then(|w| w.hit(p, cx.tol(5.0))).is_some()
 }
 
-/// Dragging a corner widget: the radius follows the pointer along the corner's diagonal.
+/// A double-click on a corner widget opens the Corners dialog for the shown corners.
+pub fn double_click(cx: &ToolContext, p: Point) -> Option<Action> {
+    let w = CornerWidgets::for_tool(cx)?;
+    w.hit(p, cx.tol(5.0))?;
+    Some(Action::Dialog(DIALOG.into(), json!({ "id": w.id.0, "corners": w.shown_indices() })))
+}
+
+/// Dragging a corner widget: the radius follows the pointer along the corner's diagonal. An
+/// Alt-click (no drag) cycles the corner kind instead.
 #[derive(Clone, Copy, Debug)]
 pub struct CornerDrag {
     widgets: CornerWidgets,
     corner: usize,
     start: Point,
     began: bool,
+    alt: bool,
     radius: f64,
     at: Point,
 }
 
 impl CornerDrag {
-    /// Start a drag when `p` is on a widget of the selection.
-    pub fn hit(cx: &ToolContext, p: Point) -> Option<Self> {
-        let widgets = CornerWidgets::for_tool(cx)?;
+    /// Start a drag when the press `ev` is on a widget of the selection.
+    pub fn hit(cx: &ToolContext, ev: &PointerEvent) -> Option<Self> {
+        let (widgets, p) = (CornerWidgets::for_tool(cx)?, ev.pos);
         let corner = widgets.hit(p, cx.tol(5.0))?;
-        Some(Self { widgets, corner, start: p, began: false, radius: widgets.radii[corner], at: p })
+        Some(Self { widgets, corner, start: p, began: false, alt: ev.mods.alt, radius: widgets.radii[corner], at: p })
     }
 
     /// The start radius (as drawn: no larger than fits) plus the pointer's travel along the
@@ -115,12 +156,19 @@ impl CornerDrag {
         }
         self.radius = self.radius_at(p);
         self.at = p;
-        out.push(Action::Preview("object.setLiveShape".into(), json!({ "id": self.widgets.id.0, "radius": self.radius })));
+        out.push(Action::Preview("object.setLiveShape".into(), self.widgets.command("radius", json!(self.radius))));
         out
     }
 
     pub fn finish(self) -> Vec<Action> {
-        if self.began { vec![Action::Commit] } else { vec![] }
+        if self.began {
+            vec![Action::Commit]
+        } else if self.alt {
+            let kind = self.widgets.kinds[self.corner].next();
+            vec![Action::Exec("object.setLiveShape".into(), self.widgets.command("kind", json!(kind)))]
+        } else {
+            vec![]
+        }
     }
 
     /// The radius readout next to the pointer.
@@ -136,7 +184,7 @@ impl CornerDrag {
 mod tests {
     use super::*;
     use crate::testutil::*;
-    use crate::{PointerEvent, PointerKind};
+    use crate::{Mods, PointerKind};
     use vectorcraft_doc::{Appearance, Node};
 
     /// A live 100 × 100 rectangle at (100, 100) with corner radius `r`.
@@ -144,7 +192,7 @@ mod tests {
         let mut d = Document::new(500.0, 500.0);
         let l = d.layers[0].id;
         let id = d.alloc_id();
-        let live = LiveShape::Rectangle { w: 100.0, h: 100.0, radii: [r; 4], xf };
+        let live = LiveShape::Rectangle { w: 100.0, h: 100.0, radii: [r; 4], kinds: Default::default(), xf };
         let mut n = Node::path(id, live.to_path(), Appearance::default_art());
         if let NodeKind::Path { live: slot, .. } = &mut n.kind {
             *slot = Some(live);
@@ -221,6 +269,55 @@ mod tests {
         assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 190.0, 110.0)).is_empty());
     }
 
+    #[test]
+    fn direct_selected_corners_show_their_widgets_alone_and_round_alone() {
+        let (d, id) = live_rect(0.0, Affine::translate((100.0, 100.0)));
+        // Direct Selection picked the bottom-right anchor.
+        let mut s = selected(id);
+        s.anchors.insert(id, [(0, 2)].into());
+        let p = paint();
+        let cx = cx(&d, &s, &p);
+        let w = CornerWidgets::of(&d, &s, 1.0).unwrap();
+        assert_eq!(w.shown, [false, false, true, false]);
+        assert_eq!(w.visible().collect::<Vec<_>>(), [Point::new(190.0, 190.0)]);
+        assert!(!over_widget(&cx, Point::new(110.0, 110.0)), "the other corners hide theirs");
+        let mut t = crate::create("directSelection");
+        assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 190.0, 191.0)).is_empty());
+        let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Drag, 175.0, 176.0));
+        assert_eq!(a[0], Action::Begin("Corner Radius".into()));
+        assert_eq!(a[1], Action::Preview("object.setLiveShape".into(), json!({"id": id.0, "radius": 15.0, "corners": [2]})));
+        assert_eq!(t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 175.0, 176.0)), vec![Action::Commit]);
+    }
+
+    #[test]
+    fn alt_click_cycles_the_kind_and_double_click_opens_the_dialog() {
+        let (d, id) = live_rect(10.0, Affine::translate((100.0, 100.0)));
+        let p = paint();
+        let alt = Mods { alt: true, ..Mods::default() };
+        let whole = selected(id);
+        let mut part = selected(id);
+        part.anchors.insert(id, [(0, 0), (0, 7)].into());
+        for (s, extra) in [(&whole, json!({})), (&part, json!({"corners": [0]}))] {
+            let cx = cx(&d, s, &p);
+            let mut want = json!({"id": id.0, "kind": "invertedRound"});
+            want.as_object_mut().unwrap().extend(extra.as_object().unwrap().clone());
+            for tool in ["selection", "directSelection"] {
+                let mut t = crate::create(tool);
+                assert!(t.pointer(&cx, &PointerEvent::new(PointerKind::Down, 110.0, 110.0).with_mods(alt)).is_empty());
+                let a = t.pointer(&cx, &PointerEvent::new(PointerKind::Up, 110.0, 110.0).with_mods(alt));
+                assert_eq!(a, vec![Action::Exec("object.setLiveShape".into(), want.clone())], "{tool}");
+            }
+        }
+        // A double-click on a widget opens Corners for the shown corners; elsewhere it doesn't.
+        let cx1 = cx(&d, &part, &p);
+        let a = crate::create("directSelection").pointer(&cx1, &PointerEvent::new(PointerKind::DoubleClick, 110.0, 110.0));
+        assert_eq!(a, vec![Action::Dialog(DIALOG.into(), json!({"id": id.0, "corners": [0]}))]);
+        let cx2 = cx(&d, &whole, &p);
+        let a = crate::create("selection").pointer(&cx2, &PointerEvent::new(PointerKind::DoubleClick, 190.0, 110.0));
+        assert_eq!(a, vec![Action::Dialog(DIALOG.into(), json!({"id": id.0, "corners": [0, 1, 2, 3]}))]);
+        assert!(crate::create("selection").pointer(&cx2, &PointerEvent::new(PointerKind::DoubleClick, 150.0, 150.0)).is_empty());
+    }
+
     #[test]
     fn widgets_off_or_elsewhere_keep_the_tools_behaviour() {
         let (d, id) = live_rect(0.0, Affine::translate((100.0, 100.0)));

crates/tools/src/direct.rs

@@ -3,7 +3,9 @@
 //! Direct Selection: click an anchor to select it (Shift toggles), click a segment to select the
 //! path's anchors on that segment, drag to move selected anchors, drag a direction handle to
 //! reshape (Shift keeps it at 45° steps round its anchor, Alt moves it alone; smart guides snap
-//! it), marquee to select anchors, drag a live rectangle's corner widget to round its corners.
+//! it), marquee to select anchors, drag a live rectangle's corner widget to round its corners
+//! (the selected ones when anchors are selected; Alt-click cycles their kind, double-click opens
+//! the Corners dialog).
 //! Group Selection: click selects the leaf; each further click on it adds the next enclosing group.
 //! Both pick the key objects of a blend. Direct Selection also edits a blend's spine: drag its
 //! points (a key object on a point moves with it) and, once a point is clicked, its handles; and
@@ -23,7 +25,7 @@ use vectorcraft_doc::{AnchorRef, Node, NodeId, NodeKind};
 use vectorcraft_geom::{PathData, Point, Rect};
 
 use crate::bbox::move_delta;
-use crate::corners::{CornerDrag, over_widget};
+use crate::corners::{self, CornerDrag, over_widget};
 use crate::meshedit::MeshEdit;
 use crate::select::{is_area_type, matrix_json};
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext};
@@ -257,8 +259,9 @@ impl Tool for DirectSelectionTool {
                     vec![Action::Exec("select.set".into(), json!({"ids": [target.0]}))]
                 }
             }
+            (PointerKind::DoubleClick, _) if !self.group => corners::double_click(cx, p).into_iter().collect(),
             (PointerKind::Down, _) => {
-                if let Some(c) = CornerDrag::hit(cx, p) {
+                if let Some(c) = CornerDrag::hit(cx, ev) {
                     self.state = State::Corner(c);
                     return vec![];
                 }

crates/tools/src/select.rs

@@ -1,6 +1,7 @@
 //! The Selection tool (V): click/shift-click, marquee, move (Alt copies, Shift constrains),
 //! bounding-box scale (Shift proportional, Alt from centre) and rotate (outside corners, Shift 45°),
-//! drag a live rectangle's corner widget to round its corners, double-click to enter isolation mode.
+//! drag a live rectangle's corner widget to round its corners (Alt-click cycles their kind,
+//! double-click opens the Corners dialog), double-click to enter isolation mode.
 //! The bounding box stands at the selection's own angle after a rotation, so its handles scale
 //! along the objects' axes. A handle drag resizes area type's frame (the type area) instead of
 //! scaling its type: the text reflows at its size.
@@ -11,7 +12,7 @@ use vectorcraft_doc::{NodeId, OrientedBox};
 use vectorcraft_geom::{Affine, Point, Rect};
 
 use crate::bbox::{Handle, hit_handle, in_rotate_zone, move_delta, rotate_for_drag, scale_for_drag};
-use crate::corners::{CornerDrag, over_widget};
+use crate::corners::{self, CornerDrag, over_widget};
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext, json_ids};
 
 #[derive(Clone, Debug, Default)]
@@ -108,6 +109,9 @@ impl Tool for SelectionTool {
         match (ev.kind, self.state.clone()) {
             (PointerKind::DoubleClick, _) => {
                 self.state = State::Idle;
+                if let Some(a) = corners::double_click(cx, p) {
+                    return vec![a];
+                }
                 if let Some(h) = hit_test(cx.doc, p, cx.hit_options()) {
                     let top = h.top_object(cx.isolation);
                     if cx.doc.node(top).is_some_and(|n| matches!(n.kind, vectorcraft_doc::NodeKind::Group { .. })) {
@@ -123,7 +127,7 @@ impl Tool for SelectionTool {
             }
             (PointerKind::Down, _) => {
                 // 1. Live Corners widgets, then the bounding-box handles of the current selection.
-                if let Some(c) = CornerDrag::hit(cx, p) {
+                if let Some(c) = CornerDrag::hit(cx, ev) {
                     self.state = State::Corner(c);
                     return vec![];
                 }

crates/ui-egui/src/canvas.rs

@@ -1239,7 +1239,7 @@ fn selection_overlay(app: &mut VectorcraftApp, p: &egui::Painter, xf: &Xf) {
         && let Some(w) = vectorcraft_tools::corners::CornerWidgets::of(&st.doc, &st.selection, xf.zoom)
     {
         let color = c32(st.doc.layer_color(w.id));
-        for sp in w.points.map(|q| xf.to_screen(q)) {
+        for sp in w.visible().map(|q| xf.to_screen(q)) {
             p.circle_filled(sp, 3.0, Color32::WHITE);
             p.circle_stroke(sp, 3.0, Stroke::new(1.0, color));
             p.circle_filled(sp, 1.0, color);

crates/ui-egui/src/dialogs/corners.rs

@@ -0,0 +1,199 @@
+//! Corners: double-clicking a Live Corners widget (or `ui.corners`) sets the corner kind and
+//! radius of a live rectangle's corners: those whose widgets show (the Direct-Selected ones, else
+//! all four). OK runs `object.setLiveShape` for them, one undo step.
+//!
+//! Fields: `id`, `corners` (indices 0–3: top-left, top-right, bottom-right, bottom-left), `kind`
+//! ("round", "invertedRound" or "chamfer") and `radius` (pt). While the corners differ in kind
+//! or radius, that field is absent and OK leaves it as it is.
+
+use serde_json::{Value, json};
+use vectorcraft_engine::doc::{NodeId, NodeKind};
+use vectorcraft_geom::shapes::CornerKind;
+
+use super::swatch_options::{grid, label};
+use super::{DialogSpec, form, run_and_close};
+use crate::state::Dialog;
+use crate::{VectorcraftApp, widgets};
+
+/// The dialog kind of Corners (the corner widgets' double-click).
+pub const KIND: &str = vectorcraft_tools::corners::DIALOG;
+
+pub(super) const SPEC: DialogSpec = DialogSpec { heading: |_| tl!("Corners").into(), body, confirm, min_width: 280.0, ..DialogSpec::FORM };
+
+/// Open Corners for `{id?, corners?}`: the live rectangle `id` (default: the selected one) and its
+/// `corners` (default: the selected corners), filled in with their kind and radius.
+pub fn open(app: &mut VectorcraftApp, p: &Value) -> Result<Value, String> {
+    let st = app.session.active().ok_or("no document")?;
+    let id = match p.get("id").and_then(Value::as_u64) {
+        Some(id) => NodeId(id),
+        None => match st.selection.objects[..] {
+            [id] => id,
+            _ => return Err("select one live rectangle, or give its `id`".into()),
+        },
+    };
+    let Some(NodeKind::Path { live: Some(live @ vectorcraft_engine::doc::LiveShape::Rectangle { .. }), .. }) = st.doc.node(id).map(|n| &n.kind)
+    else {
+        return Err("Corners edits a live rectangle".into());
+    };
+    let corners = match p.get("corners").and_then(Value::as_array) {
+        Some(a) => std::array::from_fn(|k| a.iter().any(|v| v.as_u64() == Some(k as u64))),
+        None => live.picked_corners(st.selection.partial(id)),
+    };
+    if !corners.contains(&true) {
+        return Err("give corners 0–3".into());
+    }
+    let (radius, kind) = live.corner_style(corners);
+    let mut fields = json!({"id": id.0, "corners": (0..4).filter(|k| corners[*k]).collect::<Vec<_>>()});
+    if let Some(k) = kind {
+        fields["kind"] = json!(k);
+    }
+    if let Some(r) = radius {
+        fields["radius"] = json!(r);
+    }
+    app.ui.dialog = Some(Dialog::new(KIND, fields));
+    Ok(Value::Null)
+}
+
+fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, d: &mut Dialog) -> bool {
+    let unit = app.session.general_unit();
+    let current = d.fields.get("kind").and_then(|k| serde_json::from_value::<CornerKind>(k.clone()).ok());
+    grid(ui, |ui| {
+        label(ui, tl!("Corner:"));
+        ui.vertical(|ui| {
+            for k in CornerKind::ALL {
+                let name = match k {
+                    CornerKind::Round => tl!("Round"),
+                    CornerKind::InvertedRound => tl!("Inverted Round"),
+                    CornerKind::Chamfer => tl!("Chamfer"),
+                };
+                if widgets::radio(ui, name, Some(k) == current, true) {
+                    d.fields.insert("kind".into(), json!(k));
+                }
+            }
+        });
+        ui.end_row();
+        label(ui, tl!("Radius:"));
+        form::length(ui, d, "radius", unit, 120.0);
+        ui.end_row();
+    });
+    false
+}
+
+fn confirm(app: &mut VectorcraftApp, d: &Dialog) -> Result<Value, String> {
+    let mut p = json!({"id": d.fields.get("id"), "corners": d.fields.get("corners")});
+    if let Some(k) = d.fields.get("kind") {
+        p["kind"] = k.clone();
+    }
+    if d.fields.contains_key("radius") {
+        p["radius"] = json!(d.f64("radius", 0.0));
+    }
+    run_and_close(app, "object.setLiveShape", p)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use vectorcraft_engine::Session;
+    use vectorcraft_engine::doc::LiveShape;
+    use vectorcraft_tools::corners::CornerWidgets;
+    use vectorcraft_tools::{PointerEvent, PointerKind};
+
+    /// A selected 100 pt live square at (100, 100).
+    fn app() -> (VectorcraftApp, u64) {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 400, "height": 400})).unwrap();
+        let id = app.run("shape.rectangle", json!({"x": 100, "y": 100, "width": 100, "height": 100})).unwrap()["id"].as_u64().unwrap();
+        (app, id)
+    }
+
+    fn live(app: &VectorcraftApp, id: u64) -> LiveShape {
+        let Some(NodeKind::Path { live: Some(l), .. }) = app.session.active().unwrap().doc.node(NodeId(id)).map(|n| n.kind.clone()) else {
+            panic!("not live")
+        };
+        l
+    }
+
+    fn corners(app: &VectorcraftApp, id: u64) -> ([f64; 4], [CornerKind; 4]) {
+        let LiveShape::Rectangle { radii, kinds, .. } = live(app, id) else { panic!("not a rectangle") };
+        (radii, kinds)
+    }
+
+    /// The radius the Properties panel's Corner Radius field shows.
+    fn panel_radius(app: &VectorcraftApp, id: u64) -> Option<f64> {
+        let n = app.session.active().unwrap().doc.node(NodeId(id)).unwrap().clone();
+        crate::panels::corner_radius(app, &n, &live(app, id))
+    }
+
+    fn shown(app: &mut VectorcraftApp) -> Vec<String> {
+        fn texts(s: &egui::Shape, out: &mut Vec<String>) {
+            match s {
+                egui::Shape::Text(t) => out.push(t.galley.text().to_string()),
+                egui::Shape::Vec(v) => v.iter().for_each(|s| texts(s, out)),
+                _ => {}
+            }
+        }
+        let ctx = egui::Context::default();
+        crate::theme::install_fonts(&ctx);
+        // A new window lays itself out in its first frame and paints in the next.
+        ctx.run_ui(Default::default(), |ui| super::super::show(app, ui.ctx())).textures_delta.clear();
+        let mut out = ctx.run_ui(Default::default(), |ui| super::super::show(app, ui.ctx()));
+        out.textures_delta.clear();
+        let mut v = vec![];
+        out.shapes.iter().for_each(|c| texts(&c.shape, &mut v));
+        v
+    }
+
+    #[test]
+    fn double_clicking_a_direct_selected_corner_edits_it_alone() {
+        let (mut app, id) = app();
+        // Direct Selection picks the bottom-right anchor: only its widget shows.
+        app.run("select.anchors", json!({"id": id, "anchors": [[0, 2]], "mode": "set"})).unwrap();
+        app.select_tool("directSelection");
+        let view = app.view_info();
+        let st = app.session.active().unwrap();
+        let at: Vec<_> = CornerWidgets::of(&st.doc, &st.selection, view.zoom).unwrap().visible().collect();
+        assert_eq!(at.len(), 1);
+        crate::canvas::dispatch(&mut app, &PointerEvent::new(PointerKind::DoubleClick, at[0].x, at[0].y), view);
+        let d = app.ui.dialog.clone().expect("Corners opened");
+        assert_eq!(
+            (d.kind.as_str(), d.fields.get("corners"), d.fields.get("kind"), d.f64("radius", -1.0)),
+            (KIND, Some(&json!([2])), Some(&json!("round")), 0.0)
+        );
+        let texts = shown(&mut app);
+        for s in ["Corners", "Corner:", "Round", "Inverted Round", "Chamfer", "Radius:"] {
+            assert!(texts.iter().any(|t| t == s), "{s} in {texts:?}");
+        }
+        let d = app.ui.dialog.as_mut().unwrap();
+        d.fields.insert("kind".into(), json!("chamfer"));
+        d.fields.insert("radius".into(), json!(12));
+        super::super::confirm(&mut app).unwrap();
+        assert!(app.ui.dialog.is_none());
+        assert_eq!(corners(&app, id), ([0.0, 0.0, 12.0, 0.0], [CornerKind::Round, CornerKind::Round, CornerKind::Chamfer, CornerKind::Round]));
+        // The panels' radius field shows the selected corner's radius, blank for the whole
+        // shape (its corners differ).
+        assert_eq!(panel_radius(&app, id), Some(12.0));
+        app.run("select.set", json!({"ids": [id]})).unwrap();
+        assert_eq!(panel_radius(&app, id), None);
+    }
+
+    #[test]
+    fn ui_corners_opens_on_the_selection_and_leaves_mixed_values_alone() {
+        let (mut app, id) = app();
+        app.run("object.setLiveShape", json!({"corners": [0], "radius": 5, "kind": "invertedRound"})).unwrap();
+        app.run("ui.corners", json!({})).unwrap();
+        let d = app.ui.dialog.clone().unwrap();
+        assert_eq!(d.fields.get("corners"), Some(&json!([0, 1, 2, 3])));
+        assert!(d.fields.get("kind").is_none() && d.fields.get("radius").is_none(), "mixed: {d:?}");
+        let before = corners(&app, id);
+        super::super::confirm(&mut app).unwrap();
+        assert_eq!(corners(&app, id), before);
+        // A radius for all four keeps their kinds.
+        app.run("ui.corners", json!({"id": id})).unwrap();
+        app.ui.dialog.as_mut().unwrap().fields.insert("radius".into(), json!("3 pt"));
+        super::super::confirm(&mut app).unwrap();
+        assert_eq!(corners(&app, id), ([3.0; 4], before.1));
+        // Only live rectangles, and only real corners.
+        assert!(app.run("ui.corners", json!({"id": 9999})).is_err());
+        assert!(app.run("ui.corners", json!({"corners": [7]})).is_err());
+    }
+}

crates/ui-egui/src/dialogs/mod.rs

@@ -15,6 +15,7 @@ pub mod color_guide_options;
 mod color_picker;
 mod command;
 pub mod confirm;
+pub mod corners;
 mod document_setup;
 pub mod dxf_import;
 pub mod dxf_options;
@@ -230,6 +231,7 @@ registry! {
     SpotColors: [spot_colors::KIND] => spot_colors::SPEC,
     TransformEach: [transform_each::KIND] => transform_each::SPEC,
     WidthPoint: [width_point::KIND] => width_point::SPEC,
+    Corners: [corners::KIND] => corners::SPEC,
     SavePdf: [save_pdf::KIND] => save_pdf::SPEC,
     SvgOptions: [svg_options::KIND] => svg_options::SPEC,
     NewDocumentMore: [new_document::MORE] => new_document::MORE_SPEC,

crates/ui-egui/src/dialogs/tools.rs

@@ -70,6 +70,13 @@ pub fn open_tool_dialog(app: &mut VectorcraftApp, kind: &str, p: Value) {
             }
             return;
         }
+        // Double-clicking a Live Corners widget: Corners.
+        super::corners::KIND => {
+            if let Err(e) = super::corners::open(app, &p) {
+                app.status(e);
+            }
+            return;
+        }
         // Double-clicking a slice with the Slice Selection tool: Slice Options.
         super::slices::OPTIONS => {
             if let Err(e) = super::slices::open_options(app) {

crates/ui-egui/src/i18n/es.tsv

@@ -466,6 +466,11 @@
 	Corner Radius:	Radio de esquina:
 	Corner:	Esquina:
 	Corners	Esquinas
+	Chamfer	Chaflán
+	Corners…	Esquinas…
+	Inverted Round	Redondeada invertida
+	Radius:	Radio:
+	Round	Redondeada
 	Couldn't copy to the system clipboard: {e}	No se pudo copiar al portapapeles del sistema: {e}
 	Couldn't paste from the clipboard: {e}	No se pudo pegar desde el portapapeles: {e}
 	Couldn't save recovery data: {e}	No se pudieron guardar los datos de recuperación: {e}
@@ -2953,3 +2958,7 @@
 	  — {n} characters from another font	  — {n} caracteres de otra fuente
 	[Normal Character Style]	[Estilo de carácter normal]
 	[Normal Paragraph Style]	[Estilo de párrafo normal]
+
+# Leading model (Paragraph panel menu, East Asian options).
+	Top-to-Top Leading	Interlineado de superior a superior
+	Bottom-to-Bottom Leading	Interlineado de inferior a inferior

crates/ui-egui/src/i18n/ja.tsv

@@ -11,6 +11,7 @@
 	About VectorCraft	VectorCraft について
 	All Scripts	すべての文字
 	Any Kind	すべての種類
+	Bottom-to-Bottom Leading	欧文ベースライン基準の行送り
 	Decorative	装飾
 	Favorites	お気に入り
 	Japanese	日本語
@@ -25,6 +26,7 @@
 	Serif / Mincho	明朝・セリフ
 	Settings…	環境設定…
 	Language	表示言語
+	Top-to-Top Leading	仮想ボディの上基準の行送り
 	UI Brightness	UI の明るさ
 	Dark	暗い
 	Medium Dark	やや暗い
@@ -938,6 +940,11 @@
 	Corner Radius:	角丸の半径:
 	Corner:	角の形状:
 	Corners	コーナー
+	Round	丸型
+	Radius:	半径:
+	Inverted Round	反転した丸型
+	Corners…	コーナー…
+	Chamfer	面取り
 	Create Clipping Mask	クリッピングマスクを作成
 	Create Document	ドキュメントを作成
 	Create From:	作成元:

crates/ui-egui/src/i18n/pt-br.tsv

@@ -322,6 +322,7 @@
 	Cascade	Em Cascata
 	Center Artwork	Centralizar Arte
 	Centimeters	Centímetros
+	Chamfer	Chanfro
 	Change	Alterar
 	Change All	Alterar Tudo
 	Change Case	Alterar Maiúsculas/Minúsculas
@@ -477,6 +478,7 @@
 	Corner Radius:	Raio do Canto:
 	Corner:	Canto:
 	Corners	Cantos
+	Corners…	Cantos…
 	Create	Criar
 	Create Clipping Mask	Criar Máscara de Recorte
 	Create Document	Criar Documento
@@ -1085,6 +1087,7 @@
 	Invert	Inverter
 	Invert Colors	Inverter Cores
 	Invert Mask	Inverter Máscara
+	Inverted Round	Arredondado Invertido
 	Isolate	Isolar
 	Isolate Blending	Isolar Mesclagem
 	Isolate Group	Isolar Grupo
@@ -1703,6 +1706,7 @@
 	Radial	Radial
 	Radial Glows	Brilhos Radiais
 	Radial Gradient	Gradiente Radial
+	Radius:	Raio:
 	Rainbow	Arco-íris
 	Random	Aleatório
 	Randomize Colors	Randomizar Cores
@@ -1871,6 +1875,7 @@
 	Rotate…	Girar…
 	Rotation	Rotação
 	Roughen…	Enrugar…
+	Round	Arredondado
 	Round Cap	Extremidade Redonda
 	Round Corners…	Cantos Arredondados…
 	Round Join	Junção Redonda

crates/ui-egui/src/i18n/zh-hans.tsv

@@ -243,6 +243,7 @@
 	Blur	模糊
 	Bottom	下
 	Bottom in Front	下方置前
+	Bottom-to-Bottom Leading	基线至基线行距
 	Bottom:	下：
 	Bounds	边界
 	Bounds (Fill Proportionally)	边界 (按比例填满)
@@ -466,6 +467,10 @@
 	Corner Radius:	圆角半径：
 	Corner:	转角：
 	Corners	转角
+	Round	圆角
+	Inverted Round	反向圆角
+	Corners…	转角…
+	Chamfer	倒角
 	Couldn't copy to the system clipboard: {e}	无法复制到系统剪贴板：{e}
 	Couldn't paste from the clipboard: {e}	无法从剪贴板粘贴：{e}
 	Couldn't save recovery data: {e}	无法存储恢复数据：{e}
@@ -2567,6 +2572,7 @@
 	Tools	工具
 	Top	上
 	Top in Front	上方在前
+	Top-to-Top Leading	上缘至上缘行距
 	Top:	上：
 	Total Width:	总宽度：
 	Touch Type Tool	修饰文字工具

crates/ui-egui/src/i18n/zh-hant.tsv

@@ -254,6 +254,7 @@
 	Blur	模糊
 	Bottom	下
 	Bottom in Front	下方置前
+	Bottom-to-Bottom Leading	基線至基線行距
 	Bottom:	下：
 	Bounds	邊界
 	Bounds (Fill Proportionally)	邊界 (按比例填滿)
@@ -479,6 +480,11 @@
 	Corner Radius:	圓角半徑：
 	Corner:	轉角：
 	Corners	轉角
+	Round	圓角
+	Radius:	半徑：
+	Inverted Round	反向圓角
+	Corners…	轉角…
+	Chamfer	倒角
 	Couldn't copy to the system clipboard: {e}	無法複製到系統剪貼簿：{e}
 	Couldn't paste from the clipboard: {e}	無法從剪貼簿貼上：{e}
 	Couldn't save recovery data: {e}	無法儲存復原資料：{e}
@@ -2647,6 +2653,7 @@
 	Tools	工具
 	Top	上
 	Top in Front	上方在前
+	Top-to-Top Leading	上緣至上緣行距
 	Top:	上：
 	Total Width:	總寬度：
 	Touch Type Tool	觸控文字工具

crates/ui-egui/src/menus.rs

@@ -276,7 +276,7 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "tool.options",
         "Tool Options…",
         "",
-        "{tool: id} what double-clicking a tool button opens: hand → fits the artboard in the window (view.fitArtboard), zoom → 100% (view.actualSize), rotate|scale|reflect|shear → that Object › Transform dialog (dialog `rotate`, `scale`, `reflect` or `shear`; error `nothing selected` without a selection), gradient → the Gradient panel (window.panel), eyedropper → Eyedropper Options (dialog `eyedropperOptions`, fields sampleSize, pickUp, apply; OK runs eyedropper.setOptions), printTiling → resets the print tiling (print.tiling.set {reset: true}), warp|twirl|pucker|bloat|scallop|crystallize|wrinkle → that tool's Tool Options (dialog `liquifyOptions`, fields tool, width, height, angle, intensity %, usePressure, detail, simplify, simplifyOn, rate, complexity, horizontal %, vertical %, affectAnchors, affectIn, affectOut, showBrush; OK runs tool.setOption {tool, values})",
+        "{tool: id} what double-clicking a tool button opens: hand → fits the artboard in the window (view.fitArtboard), zoom → 100% (view.actualSize), rotate|scale|reflect|shear → that Object › Transform dialog (dialog `rotate`, `scale`, `reflect` or `shear`; error `nothing selected` without a selection), selection|directSelection|groupSelection → the Move dialog (dialog `move`; the same error), gradient → the Gradient panel (window.panel), eyedropper → Eyedropper Options (dialog `eyedropperOptions`, fields sampleSize, pickUp, apply; OK runs eyedropper.setOptions), printTiling → resets the print tiling (print.tiling.set {reset: true}), warp|twirl|pucker|bloat|scallop|crystallize|wrinkle → that tool's Tool Options (dialog `liquifyOptions`, fields tool, width, height, angle, intensity %, usePressure, detail, simplify, simplifyOn, rate, complexity, horizontal %, vertical %, affectAnchors, affectIn, affectOut, showBrush; OK runs tool.setOption {tool, values})",
     ),
     (
         "ui.colorGuideOptions",
@@ -441,6 +441,12 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[
         "",
         "{id, index} open Width Point Edit for width point `index` of path `id` (dialog `widthPoint`: side1, side2 (pt), linked, adjustAdjoining; double-clicking a width point with the Width tool opens it too): OK runs stroke.widthPoint.set, discard: true (the Delete button) stroke.widthPoint.remove",
     ),
+    (
+        "ui.corners",
+        "Corners…",
+        "",
+        "{id?, corners?: [0..3…]} open Corners for live rectangle `id` (default: the selected one) and its corners (0 top-left, 1 top-right, 2 bottom-right, 3 bottom-left; default: the Direct-Selected corners, else all four) (dialog `corners`: kind (round|invertedRound|chamfer), radius (pt); double-clicking a corner widget opens it too): OK runs object.setLiveShape",
+    ),
     (
         "ui.colorGuideLimit",
         "Limit Color Guide to Library",
@@ -1126,6 +1132,7 @@ pub fn run_ui_command(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<R
             },
         },
         "ui.widthPointEdit" => crate::dialogs::width_point::open(app, p),
+        "ui.corners" => crate::dialogs::corners::open(app, p),
         "ui.colorGuideLimit" => crate::panels::color_guide::set_limit(app, p),
         "ui.savePdfDialog" => crate::dialogs::open_save_pdf(app, p),
         "file.exportAs" if s("path").is_none() => {

crates/ui-egui/src/panels/mod.rs

@@ -45,7 +45,7 @@ pub mod transparency;
 use egui::{Rect, Sense, Ui, vec2};
 use serde_json::{Value, json};
 use vectorcraft_color::{BlendMode, Color, Paint};
-use vectorcraft_doc::{Node, StrokeLayer};
+use vectorcraft_doc::{LiveShape, Node, StrokeLayer};
 use vectorcraft_engine::inspect::StrokeMixed;
 
 use crate::theme::Tokens;
@@ -57,6 +57,13 @@ pub fn first_selected(app: &VectorcraftApp) -> Option<Node> {
     first_node(app).cloned()
 }
 
+/// The radius the Live Corners of live rectangle `n` show in the panels: that of the corners the
+/// panels set (the Direct-Selected ones, else all four), blank when they differ.
+pub(crate) fn corner_radius(app: &VectorcraftApp, n: &Node, live: &LiveShape) -> Option<f64> {
+    let partial = app.session.active().and_then(|d| d.selection.partial(n.id));
+    live.corner_style(live.picked_corners(partial)).0
+}
+
 /// Number of selected objects.
 pub(crate) fn selection_len(app: &VectorcraftApp) -> usize {
     app.session.active().map(|d| d.selection.len()).unwrap_or(0)

crates/ui-egui/src/panels/paragraph.rs

@@ -140,7 +140,8 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
 }
 
 pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
-    let has = text_style(app).is_some();
+    let style = text_style(app);
+    let has = style.is_some();
     let hidden: bool = pstate(ui.ctx(), "pa-hide-options");
     if menu_item(ui, if hidden { tl!("Show Options") } else { tl!("Hide Options") }, true, false) {
         set_pstate(ui.ctx(), "pa-hide-options", !hidden);
@@ -149,6 +150,18 @@ pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
     for l in [tl!("Roman Hanging Punctuation"), tl!("Justification…"), tl!("Hyphenation…")] {
         menu_item(ui, l, false, false);
     }
+    // How leading is measured (Japanese layout measures it from em box top to em box top), with
+    // the East Asian options.
+    if app.session.prefs.show_east_asian_options {
+        ui.separator();
+        let top_to_top = style.as_ref().is_some_and(|(_, p)| p.leading_model == vectorcraft_doc::LeadingModel::EmBoxTop);
+        if menu_item(ui, tl!("Top-to-Top Leading"), has, top_to_top) {
+            format(app, json!({"leadingModel": "emBoxTop"}));
+        }
+        if menu_item(ui, tl!("Bottom-to-Bottom Leading"), has, has && !top_to_top) {
+            format(app, json!({"leadingModel": "romanBaseline"}));
+        }
+    }
     ui.separator();
     menu_item(ui, tl!("Single-line Composer"), false, false);
     menu_item(ui, tl!("Every-line Composer"), false, true);
@@ -157,7 +170,7 @@ pub fn menu(app: &mut VectorcraftApp, ui: &mut Ui) {
         para_cmd(app, "text.setStyle", json!({"justify": "auto"}));
         format(
             app,
-            json!({"leftIndent": 0, "rightIndent": 0, "firstLineIndent": 0, "spaceBefore": 0, "spaceAfter": 0, "hyphenate": false, "direction": "auto"}),
+            json!({"leftIndent": 0, "rightIndent": 0, "firstLineIndent": 0, "spaceBefore": 0, "spaceAfter": 0, "hyphenate": false, "direction": "auto", "leadingModel": "romanBaseline"}),
         );
     }
 }

crates/ui-egui/src/panels/properties.rs

@@ -4,7 +4,7 @@ use egui::Ui;
 use serde_json::json;
 use vectorcraft_doc::{NodeKind, Unit};
 
-use super::{first_selected, pstate, set_pstate};
+use super::{corner_radius, first_selected, pstate, set_pstate};
 use crate::theme::Tokens;
 use crate::widgets::{self, dim_label, divider, section_header};
 use crate::{VectorcraftApp, icons};
@@ -317,10 +317,10 @@ pub fn transform_section(app: &mut VectorcraftApp, ui: &mut Ui) {
         && let NodeKind::Path { live: Some(live), .. } = &n.kind
     {
         match live {
-            vectorcraft_doc::LiveShape::Rectangle { radii, .. } => {
+            vectorcraft_doc::LiveShape::Rectangle { .. } => {
                 ui.horizontal(|ui| {
                     dim_label(ui, tl!("Corner Radius:"));
-                    if let Some(r) = widgets::num_field(ui, "radius", Some(radii[0]), units, 80.0) {
+                    if let Some(r) = widgets::num_field(ui, "radius", corner_radius(app, &n, live), units, 80.0) {
                         app.run("object.setLiveShape", json!({"radius": r})).ok();
                     }
                 });

crates/ui-egui/src/panels/transform.rs

@@ -7,7 +7,7 @@ use serde_json::json;
 use vectorcraft_doc::NodeKind;
 use vectorcraft_geom::Rect;
 
-use super::{first_selected, pstate, set_pstate};
+use super::{corner_radius, first_selected, pstate, set_pstate};
 use crate::theme::Tokens;
 use crate::widgets::{self, menu_item};
 use crate::{VectorcraftApp, icons};
@@ -170,11 +170,11 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
     {
         widgets::divider(ui);
         match live {
-            vectorcraft_doc::LiveShape::Rectangle { radii, .. } => {
+            vectorcraft_doc::LiveShape::Rectangle { .. } => {
                 widgets::subheader(ui, tl!("Rectangle Properties:"));
                 ui.horizontal(|ui| {
                     widgets::dim_label(ui, tl!("Corner Radius:"));
-                    if let Some(r) = widgets::num_field(ui, "xfp-radius", Some(radii[0]), units, 80.0) {
+                    if let Some(r) = widgets::num_field(ui, "xfp-radius", corner_radius(app, &n, live), units, 80.0) {
                         app.run("object.setLiveShape", json!({"radius": r})).ok();
                     }
                 });

crates/ui-egui/src/recovery.rs

@@ -4,8 +4,10 @@
 //! left copies behind (a crash). The copies themselves are the engine's
 //! ([`vectorcraft_engine::cmd::recovery`]).
 
+use std::sync::Arc;
+
 use serde_json::{Value, json};
-use vectorcraft_engine::cmd::recovery;
+use vectorcraft_engine::cmd::recovery::{self, RecoveryStore};
 
 use crate::VectorcraftApp;
 use crate::background::{self, Writer};
@@ -36,7 +38,14 @@ pub fn frame(app: &mut VectorcraftApp, now: f64) -> Option<f64> {
     tick(app, now);
     if !(0.0..recovery::HEARTBEAT_EVERY).contains(&(now - app.recovery.beat)) {
         app.recovery.beat = now;
-        recovery::heartbeat(&app.session);
+        // Copies another app removed while this one's timers were paused (it took this one for
+        // gone) are written again at once.
+        let lost = recovery::heartbeat(&mut app.session);
+        if !lost.is_empty()
+            && let Some(store) = recovery::store(&app.session)
+        {
+            write(app, &store, |uid| lost.contains(&uid));
+        }
     }
     let interval = f64::from(app.session.prefs.autosave_interval.max(1)) * 60.0;
     let next = app.recovery.last.map(|t| t + interval - now)?;
@@ -77,10 +86,16 @@ pub fn tick(app: &mut VectorcraftApp, now: f64) -> usize {
             return 0;
         }
     }
+    write(app, &store, |_| true)
+}
+
+/// Start a recovery copy of every document that needs one and `pick` picks (by uid) → how many
+/// were started.
+fn write(app: &mut VectorcraftApp, store: &Arc<dyn RecoveryStore>, pick: impl Fn(u64) -> bool) -> usize {
     recovery::forget_clean(&mut app.session);
-    let jobs = match recovery::jobs(&mut app.session, &store) {
+    let jobs = match recovery::jobs(&mut app.session, store) {
         // A document whose save or last copy is still being written waits for the next round.
-        Ok((jobs, _)) => jobs.into_iter().filter(|j| !app.background.busy_with(j.uid)).collect::<Vec<_>>(),
+        Ok((jobs, _)) => jobs.into_iter().filter(|j| pick(j.uid) && !app.background.busy_with(j.uid)).collect::<Vec<_>>(),
         Err(e) => {
             app.status(format!("Couldn't save recovery data: {e}"));
             return 0;

crates/ui-egui/src/shortcuts.rs

@@ -211,7 +211,9 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
             // A key the tool claims (Esc with a loaded place cursor) is only the tool's.
             let claimed = app.session.tool_claims_key(tk, view);
             let r = app.session.tool_key(tk, Mods::default(), view);
-            if claimed {
+            // Enter also takes what the tool asks of the UI: Rotate, Scale, Reflect and Shear open
+            // their dialog with it.
+            if claimed || (k == Key::Enter && !busy) {
                 crate::canvas::apply_requests(app, r);
             }
             if k == Key::Escape && !busy && !claimed {
@@ -223,6 +225,19 @@ pub fn handle(app: &mut VectorcraftApp, ctx: &egui::Context) {
                     app.ui.flyout = None;
                 }
             }
+            if k == Key::Enter && !busy && !claimed {
+                // Enter with a selection tool opens the Move dialog, as a double-click on its button
+                // does.
+                let tool = app.session.tool_id();
+                if app.ui.dialog.is_none() && crate::canvas::is_selection_tool(tool) {
+                    // Nothing selected: it fails and nothing opens (the menu item is disabled then too).
+                    let _ = crate::toolbar::open_options(app, tool);
+                }
+                // The Enter that opened a dialog isn't also its OK: dialogs take Enter, this frame too.
+                if app.ui.dialog.is_some() {
+                    ctx.input_mut(|i| i.consume_key(Modifiers::NONE, Key::Enter));
+                }
+            }
         }
     }
     if typing {
@@ -526,6 +541,54 @@ mod tests {
         assert_eq!(grid(&mut app, &[Key::ArrowLeft, Key::ArrowDown]), (rows, columns + 1));
     }
 
+    /// Enter opens the tool's dialog: the Move dialog for the selection tools, the tool's own for
+    /// Rotate, Scale, Reflect and Shear. The Enter that opens it isn't also its OK.
+    #[test]
+    fn enter_opens_the_tools_dialog_and_leaves_it_open() {
+        let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());
+        app.session.execute("file.new", &json!({"width": 400, "height": 300})).unwrap();
+        let ctx = egui::Context::default();
+        let enter = || egui::Event::Key { key: Key::Enter, physical_key: None, pressed: true, repeat: false, modifiers: Modifiers::NONE };
+        // A whole app frame: the shortcuts first, then the UI, where a dialog takes its Enter.
+        let frame = |app: &mut VectorcraftApp, events: Vec<egui::Event>| {
+            let screen_rect = Some(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1280.0, 800.0)));
+            let mut out = ctx.run_ui(egui::RawInput { events, screen_rect, ..Default::default() }, |ui| {
+                app.logic(ui.ctx());
+                app.ui(ui);
+            });
+            out.textures_delta.clear();
+        };
+        let kind = |app: &VectorcraftApp| app.ui.dialog.as_ref().map(|d| d.kind.clone());
+        let steps = |app: &VectorcraftApp| app.session.active().unwrap().history.undo.len();
+        app.select_tool("selection");
+        frame(&mut app, vec![enter()]);
+        assert_eq!(kind(&app), None, "nothing is selected");
+        app.session.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 30})).unwrap();
+        for (tool, dialog) in [
+            ("selection", "move"),
+            ("directSelection", "move"),
+            ("groupSelection", "move"),
+            ("rotate", "rotate"),
+            ("scale", "scale"),
+            ("reflect", "reflect"),
+            ("shear", "shear"),
+        ] {
+            app.select_tool(tool);
+            let before = steps(&app);
+            frame(&mut app, vec![enter()]);
+            assert_eq!(kind(&app).as_deref(), Some(dialog), "{tool}: Enter opens it");
+            frame(&mut app, vec![]);
+            assert_eq!(kind(&app).as_deref(), Some(dialog), "{tool}: and it stays open");
+            assert_eq!(steps(&app), before, "{tool}: the Enter that opened it didn't confirm it");
+            // The next Enter is its OK.
+            frame(&mut app, vec![enter()]);
+            assert_eq!((kind(&app), steps(&app)), (None, before + 1), "{tool}: Enter confirms");
+        }
+        app.select_tool("rectangle");
+        frame(&mut app, vec![enter()]);
+        assert_eq!(kind(&app), None, "another tool has its own Enter");
+    }
+
     #[test]
     fn comma_and_period_reapply_the_last_colour_and_gradient() {
         let mut app = VectorcraftApp::new(vectorcraft_engine::Session::new(), Default::default());

crates/ui-egui/src/tests_recovery.rs

@@ -176,3 +176,25 @@ fn the_timer_asks_for_frames_while_idle() {
     app.session.prefs.autosave_recovery = false;
     assert!(recovery::frame(&mut app, 1.0).is_none());
 }
+
+/// Issue #367: a tab whose timers were paused (in the background) long enough for another tab to
+/// take it for gone and discard its copy writes the copy again on its first heartbeat after it
+/// resumes, even with the timer off (the copy was written by hand).
+#[test]
+fn a_resumed_tab_writes_again_the_copies_another_tab_discarded() {
+    let store = Arc::new(MemoryStore::without_locks());
+    let mut a = app_with(&store, Services::default());
+    a.session.prefs.autosave_recovery = false;
+    a.run("file.recovery.save", json!({})).unwrap();
+    recovery::frame(&mut a, 0.0);
+    store.set_now(1_000_000 + 400);
+    let mut b = VectorcraftApp::new(Session::new(), Services { recovery_store: Some(store.clone()), ..Default::default() });
+    b.run("file.recovery.discard", json!({})).unwrap();
+    assert_eq!(copies(&store), 0);
+    store.set_now(1_000_000 + 410);
+    recovery::frame(&mut a, 30.0);
+    assert_eq!(copies(&store), 0, "the store is looked at with the heartbeat, not every frame");
+    recovery::frame(&mut a, 410.0);
+    assert_eq!(copies(&store), 1);
+    assert_eq!(a.ui.status, "Saved recovery data for Untitled-1");
+}

crates/ui-egui/src/toolbar.rs

@@ -218,19 +218,21 @@ pub fn show(app: &mut VectorcraftApp, ui: &mut Ui) {
 /// the Gradient panel, the Eyedropper's the Eyedropper Options dialog, a Liquify tool's its Tool
 /// Options dialog, the Blend tool's Blend
 /// Options; the Print Tiling tool's resets the print tiling. As in the reference app, the Hand
-/// tool's fits the artboard in the window, the Zoom tool's shows it at 100%, and the Rotate, Scale,
-/// Reflect and Shear tools' are their Object › Transform dialogs.
+/// tool's fits the artboard in the window, the Zoom tool's shows it at 100%, the Rotate, Scale,
+/// Reflect and Shear tools' are their Object › Transform dialogs, and the selection tools' are the
+/// Move dialog.
 pub fn open_options(app: &mut VectorcraftApp, tool: &str) -> Result<serde_json::Value, String> {
     match tool {
         "hand" => app.run("view.fitArtboard", json!({})),
         "zoom" => app.run("view.actualSize", json!({})),
-        "rotate" | "scale" | "reflect" | "shear" => {
-            let id = format!("object.{tool}");
+        "rotate" | "scale" | "reflect" | "shear" | "selection" | "directSelection" | "groupSelection" => {
+            let dialog = if crate::canvas::is_selection_tool(tool) { "move" } else { tool };
+            let id = format!("object.{dialog}");
             if let Some(c) = vectorcraft_engine::find_command(&id) {
                 (c.enabled)(&app.session)?;
             }
             crate::menus::invoke(app, &id, json!({}));
-            Ok(json!({ "dialog": tool }))
+            Ok(json!({ "dialog": dialog }))
         }
         "gradient" if app.ui.open_panel.as_deref() == Some("gradient") => Ok(json!({ "open": "gradient" })),
         "gradient" => app.run("window.panel", json!({ "panel": "gradient" })),
@@ -538,6 +540,33 @@ pub(crate) mod tests {
         assert!((b.x0 - 20.0).abs() < 1e-9 && (b.y0 - 0.0).abs() < 1e-9 && (b.width() - 20.0).abs() < 1e-9, "{b:?}");
     }
 
+    #[test]
+    fn double_clicking_a_selection_tool_opens_the_move_dialog() {
+        let mut app = VectorcraftApp::new(Session::new(), Default::default());
+        app.run("file.new", json!({"width": 300, "height": 200})).unwrap();
+        let ctx = egui::Context::default();
+        // The Selection tool's button is the first one.
+        let selection = frame(&mut app, &ctx, 0.0, vec![])[0];
+        // Nothing selected: Move is disabled, so nothing opens.
+        double_click(&mut app, &ctx, 1.0, selection.center());
+        assert!(app.ui.dialog.is_none());
+        assert_eq!(app.run("tool.options", json!({"tool": "directSelection"})), Err("nothing selected".into()));
+        let id = app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 40, "height": 20})).unwrap()["id"].as_u64().unwrap();
+        double_click(&mut app, &ctx, 2.0, selection.center());
+        assert_eq!(app.ui.dialog.take().map(|d| d.kind), Some("move".to_string()));
+        // The Direct Selection and Group Selection tools open it too.
+        for tool in ["directSelection", "groupSelection"] {
+            app.run("tool.options", json!({"tool": tool})).unwrap();
+            assert_eq!(app.ui.dialog.take().map(|d| d.kind), Some("move".to_string()), "{tool}");
+        }
+        // OK moves the selection by what was typed.
+        app.run("tool.options", json!({"tool": "selection"})).unwrap();
+        app.ui.dialog.as_mut().unwrap().fields.insert("dx".into(), json!("25 pt"));
+        crate::dialogs::confirm(&mut app).unwrap();
+        let b = app.session.active().unwrap().doc.node(vectorcraft_doc::NodeId(id)).unwrap().geometric_bounds().unwrap();
+        assert_eq!((b.x0, b.y0), (35.0, 10.0));
+    }
+
     #[test]
     fn right_clicking_a_tool_group_opens_its_flyout() {
         let mut app = VectorcraftApp::new(Session::new(), Default::default());

docs/control-protocol.md

@@ -89,8 +89,11 @@ for `eyedropper` it opens Eyedropper Options, an `eyedropperOptions` dialog (fie
 `apply`, the attribute trees of `eyedropper.setOptions`) whose `ui.dialog.confirm` runs `eyedropper.setOptions` (what
 `appearance.copyFrom` copies). For `hand` it fits the artboard in the window (`view.fitArtboard`) and for `zoom` it
 shows 100% (`view.actualSize`). For `rotate`, `scale`, `reflect` and `shear` it opens the same dialog as Object ›
-Transform (dialog kind = the tool id), or fails with `nothing selected`. Gradient tool handles snap to
-anchors, edges and smart guides; Shift constrains them to 45° steps from the `constrainAngle` preference.
+Transform (dialog kind = the tool id), or fails with `nothing selected`. For `selection`, `directSelection` and
+`groupSelection` it opens the Move dialog (kind `move`), with the same failure. `ui.key` Enter with one of those seven
+tools opens its dialog too (nothing happens without a selection), with the transform tools' `origin` at their reference
+point. Gradient tool handles snap to anchors, edges and smart guides; Shift constrains them to 45° steps from the
+`constrainAngle` preference.
 
 Effect dialogs: `engine.execute {command: "effect.dialog", params: {effect, index?, item?}}` opens the `effect` dialog
 (fields: the effect's parameters, `preview`). With `index` it edits that applied effect of `item` (null: the object's
@@ -250,6 +253,11 @@ Width Point Edit: double-clicking a width point with the Width tool, or `ui.widt
 `adjustAdjoining`). `ui.dialog.confirm` runs `stroke.widthPoint.set` with them; `ui.dialog.set {field: "discard",
 value: true}` then confirm (the Delete button) removes the point with `stroke.widthPoint.remove`.
 
+Corners: double-clicking a Live Corners widget with the Selection or Direct Selection tool, or `ui.corners {id?,
+corners?}`, opens the `corners` dialog for a live rectangle's corners (the Direct-Selected ones, else all four; fields
+`id`, `corners`: indices 0–3 clockwise from the top-left, `kind`: round, invertedRound or chamfer, `radius` in points;
+`kind` or `radius` is absent while the corners differ). `ui.dialog.confirm` runs `object.setLiveShape` with them.
+
 Perspective plane options: double-clicking a plane widget of the perspective grid, or `ui.perspectivePlane {plane}`,
 opens the `perspectivePlane` dialog (fields `plane`: left, right or ground; `location`: points along the plane's
 normal; `objects`: none, move or copy). `ui.dialog.confirm` runs `perspective.plane.move` with them.

docs/development.md

@@ -21,6 +21,7 @@ How the web shell (`apps/vectorcraft-web/src/web.rs`) differs from desktop:
 - **Open** sets `Services::open_async`, which shows `rfd::AsyncFileDialog`. The bytes arrive in `Services::inbox`, which the app drains every frame.
 - **Save / Save As / Export** go through `Services::download`: a Blob, an object URL and a temporary `<a download>`, all created from Rust. There is no save dialog, so the suggested name becomes the download name.
 - **Drag-and-drop:** `WebShell` takes the frame's `dropped_files` before the app sees them, reads each with `DroppedFile::bytes_async` and pushes the bytes into the inbox (files dropped on a canvas go to `Services::place_inbox` with their `place::DropAt`: the document they were dropped on, by uid, and the point). A file that arrives after another document became active still lands in its own document, which becomes active again; if that document closed meanwhile, the file is not placed and the status bar says so. (The app's synchronous drop path is compiled out on wasm32.)
+- **Data Recovery** keeps its copies in `localStorage` (`vectorcraft-recovery/<area>/<name>`, shared by the site's tabs), so tabs can't lock their areas the way desktop apps lock a folder (`RecoveryStore::lock`). Each tab holds its area with a heartbeat it refreshes every minute and, where the browser has Web Locks (secure pages: `https://` or localhost), with a Web Lock named after the area (`apps/vectorcraft-web/src/locks.rs`, through `js_sys::Reflect` since web-sys has them only as an unstable API). The browser releases the lock only when the tab is gone, not while its timers are paused in the background, which a heartbeat can't tell apart (#367). `navigator.locks.query()` is asynchronous, so the shell keeps a snapshot refreshed every 10 seconds (taken once before the first frame); a snapshot older than a minute counts every area as held. An area is offered as a crash's leftovers only when no tab holds its lock and its heartbeat is older than three intervals. Without Web Locks a paused tab can still be taken for gone; it repairs that when it resumes: its next heartbeat (or recovery save) writes again the copies missing from its area, and a heartbeat newer than the one the other tab wrote taking the area over makes the area running again for that tab.
 - **No control server:** browsers can't listen on TCP. To automate the web build, drive headless Chrome with `--remote-debugging-port`.
 - Quick smoke test: `"/Applications/Google Chrome.app/Contents/MacOS/Google Chrome" --headless=new --enable-unsafe-webgpu --screenshot=web.png --window-size=1440,900 --virtual-time-budget=15000 http://127.0.0.1:8766/` (headless Chrome on macOS gets a real WebGPU adapter).
 

docs/mcp.md

@@ -333,6 +333,10 @@ Images follow the `compression` settings of their kind (`color`, `gray`, or `mon
 `abovePpi` as placed they are resampled (`downsample`: `average`, `subsample` or `bicubic`) to `ppi`, and compressed
 with `zip`, `jpeg` (at `quality`; images with transparency stay lossless) or `auto` (JPEGs stay JPEG, the others
 lossless). `none`, `jpeg2000`, CCITT and `runLength` are written as ZIP, with a warning when an image needs them.
+CMYK images stay CMYK (DeviceCMYK, or ICC-based with the CMYK profile when colours are tagged, as in PDF/X-3 and
+PDF/X-4): a CMYK JPEG neither resampled nor recompressed is written unchanged, and the others' ink amounts are
+resampled and compressed again (CMYK JPEG or ZIP). `output.conversion` converts them like CMYK colours: `destination`
+to another CMYK profile or to RGB, `preserveNumbers` (and PDF/X-1a) keeps their numbers in a CMYK destination.
 `document.pdfSettings` lists the options that differ from the preset and the warnings without writing a file.
 `thumbnails: true` embeds each page drawn small (106 px on its long side, without the layers the page leaves out) as
 its `/Thumb` image. `fastWebView: true` writes a linearised file (the linearization dictionary first, then the first
@@ -348,7 +352,10 @@ Opening a PDF (or `.ai`) imports every page as an artboard and layer; `document.
 and `password` for an encrypted file. `document.pdfInfo` reads a file without opening it: the page count, each page's
 size and boxes, `needsPassword`, and with `thumbnail: n` a PNG of page n. Imported colours keep their model:
 DeviceCMYK and CMYK ICC colours stay CMYK (a file painted mostly in CMYK opens as a CMYK document), DeviceGray is Gray,
-and Separation and DeviceN inks become spot swatches the art links to at its tint (gradient stops too).
+and Separation and DeviceN inks become spot swatches the art links to at its tint (gradient stops too). CMYK images
+(DeviceCMYK, or ICC-based with four components) keep their ink amounts: a CMYK JPEG as it is, any other as a CMYK TIFF
+(masked CMYK images, and ones with 1, 2 or 4 bits per sample, open in RGB with a warning). Placing a CMYK TIFF keeps it
+CMYK too.
 `colorMode: "rgb" | "cmyk"` opens any file in that mode instead, its colours converted as `file.documentColorMode` does:
 
 ```json
@@ -363,10 +370,15 @@ What a PDF holds comes in as editable art: soft masks become opacity masks (an a
 the backdrop colour gives Clip, an inverting transfer function Invert), transparency groups keep isolation and knockout,
 tiling patterns become pattern swatches, patch and triangle mesh shadings become gradient meshes, and gradients keep
 their stop opacity and stop where the shading doesn't extend. Text becomes point type, one object per run of a line in
-the file's font (by name; fonts that aren't available are listed in `warnings` and show in the fallback font) —
-`textAs: "outlines"` keeps glyph outlines instead. Optional content groups (the layers of PDF and PDF-compatible `.ai`
-files) become layers with their name, visibility, print state and lock, art that is off coming in as a hidden layer;
-art outside them goes to a layer per page (except the opaque white page a `.ai` paints under its layers, which isn't art). `layers: false` gives one layer per page of only what shows:
+the file's font (by name; fonts that aren't available are listed in `warnings` and show in the fallback font, and
+every export that draws that type — PDF, EPS, EMF/WMF, raster images, SVG with outlined or embedded fonts — says in
+its `warnings` that it wrote the fallback font) — `textAs: "outlines"` keeps the glyph outlines the file draws instead
+(its embedded fonts, installed or not). Strokes stay live strokes (width, cap, join, miter limit, dash and paint), and
+an object written as a fill and then a stroke of the same outline is one path with both. Optional content groups (the
+layers of PDF and PDF-compatible `.ai` files) become layers with their name, visibility (the default configuration's,
+or a view state that is off), print state and lock, nested as sublayers the way the file's layer order nests them; art
+that is off comes in as a hidden layer. Art outside them goes to a layer per page (except the opaque white page a `.ai`
+paints under its layers, which isn't art). `layers: false` gives one layer per page of only what shows:
 
 ```json
 {"name":"run_command","arguments":{"command":"document.open","params":{"path":"/tmp/map.pdf","textAs":"outlines","layers":false}}}
@@ -1027,6 +1039,22 @@ size. The journal entry of a scaling command records the `strokes` and `corners`
 {"name":"run_command","arguments":{"command":"object.transformEach","params":{"scaleH":50,"scaleV":50,"strokes":false}}}
 ```
 
+## Live Corners
+
+`object.setLiveShape {id?, ids?, radius?, kind?, corners?}` sets the corners of live rectangles (one undo step):
+`radius` (pt) and `kind` (`round`, `invertedRound` or `chamfer`) go to the `corners` given (0 top-left, 1 top-right,
+2 bottom-right, 3 bottom-left), else to the corners holding a Direct-Selected anchor (`select.anchors`), else to all
+four. Each corner keeps its own radius and kind (the shape's `live` in queries has `radii` and, when a corner isn't
+round, `kinds`); a corner with no radius is one anchor, a cut one two, and Direct-Selected corners stay selected as
+that changes. With the Selection or Direct Selection tool, dragging a corner widget rounds the corners whose widgets
+show (all four, or the Direct-Selected ones), Alt-clicking one cycles their kind and double-clicking one opens Corners
+(`ui.corners {id?, corners?}`, dialog `corners`: `kind`, `radius`; OK runs `object.setLiveShape`).
+
+```json
+{"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"id":12,"corners":[1],"radius":16}}}
+{"name":"run_command","arguments":{"command":"object.setLiveShape","params":{"id":12,"corners":[0,3],"radius":8,"kind":"chamfer"}}}
+```
+
 ## Use Preview Bounds
 
 With the preference `usePreviewBounds` on (`prefs.set {key: "usePreviewBounds", value: true}`; also the Align panel
@@ -1545,9 +1573,12 @@ The copies live in the `recoveryFolder` preference's folder (default: `Data Reco
 none when the app runs with `VECTORCRAFT_NO_PREFS`) or, on the web, in browser storage.
 
 Each running app (each browser tab) keeps its copies in an area of its own (`<area>/<name>`): a sub-folder whose
-`.lock` file it keeps locked while it runs, or on the web an area with a heartbeat it refreshes every minute. Only
-areas nobody holds are offered: their lock is free, or their heartbeat is older than three intervals (at least three
-minutes). Several apps running at once (agents' instances included) never see each other's copies as crash leftovers,
+`.lock` file it keeps locked while it runs, or on the web an area with a heartbeat it refreshes every minute and a Web
+Lock the browser holds until the tab is gone (where the browser has Web Locks: secure pages). Only areas nobody holds
+are offered: their lock is free, or no tab holds their Web Lock and their heartbeat is older than three intervals (at
+least three minutes). A background tab whose timers are paused therefore keeps its copies. Without Web Locks another
+tab can take such a tab for gone; when it resumes, its next heartbeat or recovery save writes its missing copies
+again. Several apps running at once (agents' instances included) never see each other's copies as crash leftovers,
 and an area being restored or discarded is held, so two apps launched together never both take it.
 
 `file.recovery.list` → `{copies: [{file, title, path, format, saved, open, running}], location}` (`open`: the copy of a