diff --git a/.github/workflows/freebsd.yml b/.github/workflows/freebsd.yml
index fe8cc88e11..7758cc108d 100644
--- a/.github/workflows/freebsd.yml
+++ b/.github/workflows/freebsd.yml
@@ -2,16 +2,19 @@
 # (GitHub has no FreeBSD runners). GPU tests skip themselves when the VM has no adapter.
 name: FreeBSD
 
+# The VM build is slow, so it runs nightly on main and on pushes to `release`, not on every push
+# or dependency change: a drifted dependency still shows up within a day, and always before a
+# release ships. PRs that change the FreeBSD packaging itself still run it.
 on:
+  schedule:
+    - cron: "27 4 * * *"
   push:
-    branches: [main]
+    branches: [release]
   pull_request:
     paths:
-      - Cargo.toml
-      - Cargo.lock
-      - "**/Cargo.toml"
       - "crates/fonts/**"
       - .github/workflows/freebsd.yml
+      - packaging/env.sh
   workflow_dispatch:
 
 concurrency:
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
index ca4b173184..6a73f61245 100644
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@@ -35,3 +35,9 @@ jobs:
       APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
       WINDOWS_CERTIFICATE: ${{ secrets.WINDOWS_CERTIFICATE }}
       WINDOWS_CERTIFICATE_PASSWORD: ${{ secrets.WINDOWS_CERTIFICATE_PASSWORD }}
+      AZURE_TENANT_ID: ${{ secrets.AZURE_TENANT_ID }}
+      AZURE_CLIENT_ID: ${{ secrets.AZURE_CLIENT_ID }}
+      AZURE_CLIENT_SECRET: ${{ secrets.AZURE_CLIENT_SECRET }}
+      AZURE_SIGNING_ENDPOINT: ${{ secrets.AZURE_SIGNING_ENDPOINT }}
+      AZURE_SIGNING_ACCOUNT: ${{ secrets.AZURE_SIGNING_ACCOUNT }}
+      AZURE_CERT_PROFILE: ${{ secrets.AZURE_CERT_PROFILE }}
diff --git a/.github/workflows/windows-arm64.yml b/.github/workflows/windows-arm64.yml
index ef71cd78b0..efac5e149d 100644
--- a/.github/workflows/windows-arm64.yml
+++ b/.github/workflows/windows-arm64.yml
@@ -4,19 +4,17 @@
 # out for now: PdfCraft saw an intermittent access violation in egui UI tests there.)
 name: Windows ARM64
 
+# Nightly on main and on pushes to `release` (dependency and runner-image drift shows up within a
+# day, and always before a release ships), and on PRs that change the Windows packaging itself.
 on:
+  schedule:
+    - cron: "13 6 * * *"
   push:
-    branches: [main]
+    branches: [release]
   pull_request:
     paths:
-      - Cargo.toml
-      - Cargo.lock
-      - "**/Cargo.toml"
-      - "**/build.rs"
       - .github/workflows/windows-arm64.yml
       - packaging/windows/**
-  schedule:
-    - cron: "41 4 * * 1" # weekly, so drift in the runner images shows up
   workflow_dispatch:
 
 concurrency:
diff --git a/Cargo.lock b/Cargo.lock
index dc6b79b979..b6665923d1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -5001,20 +5001,26 @@ name = "wordcraft"
 version = "0.5.0"
 dependencies = [
  "arboard",
+ "dispatch2",
  "eframe",
  "egui",
  "fmv-macos-events",
  "getrandom 0.3.4",
  "log",
+ "objc2 0.6.5",
+ "objc2-app-kit 0.3.2",
  "open",
  "pollster 0.4.0",
  "rfd",
  "serde_json",
+ "windows",
  "winresource",
  "wordcraft-control-key",
  "wordcraft-doc",
  "wordcraft-engine",
+ "wordcraft-fonts",
  "wordcraft-ui-egui",
+ "zbus",
 ]
 
 [[package]]
@@ -5115,6 +5121,8 @@ dependencies = [
  "log",
  "skrifa 0.47.0",
  "unicode-bidi",
+ "unicode-script",
+ "wuff",
 ]
 
 [[package]]
@@ -5143,6 +5151,7 @@ version = "0.5.0"
 dependencies = [
  "image",
  "js-sys",
+ "kurbo",
  "log",
  "serde",
  "serde_json",
@@ -5256,6 +5265,7 @@ dependencies = [
  "web-sys",
  "wordcraft-doc",
  "wordcraft-engine",
+ "wordcraft-fonts",
  "wordcraft-ui-egui",
 ]
 
@@ -5292,6 +5302,17 @@ version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3ad82d2a33cdc9674dc7465672f271e096168fcdbe0f799d9e6db8c5892679dc"
 
+[[package]]
+name = "wuff"
+version = "0.2.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "200a7b806377b65f1ff9a985874332f15357c87e5dd7855f35f06dade95b8b3d"
+dependencies = [
+ "brotli-decompressor",
+ "bytes",
+ "flate2",
+]
+
 [[package]]
 name = "x11-dl"
 version = "2.21.0"
diff --git a/Cargo.toml b/Cargo.toml
index 98af82ccb0..438cbc9ee5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -40,12 +40,16 @@ rayon = "1"
 unicode-bidi = "0.3"
 unicode-segmentation = "1"
 unicode-linebreak = "0.1"
+unicode-script = "0.5"
 regex = { version = "1", default-features = false, features = ["std", "unicode", "perf"] }
 regex-automata = { version = "0.4", default-features = false, features = ["std", "syntax", "meta", "nfa-pikevm", "unicode"] }
 
 # text / rendering / formats
 skrifa = "0.47"
 harfrust = "0.13"
+# WOFF / WOFF2 web fonts added by the user (#582): pure Rust (MIT); its brotli and zlib decoders
+# (brotli-decompressor, flate2) are already in the tree.
+wuff = "0.2.9"
 vello_cpu = "0.2"
 image = { version = "0.25", default-features = false, features = ["png", "jpeg", "webp", "gif", "bmp", "tiff"] }
 krilla = { version = "0.8", features = ["pdf"] }
diff --git a/README.md b/README.md
index f74661252a..24828507ee 100644
--- a/README.md
+++ b/README.md
@@ -234,6 +234,13 @@ Remove-Item Env:WGPU_BACKEND                     # restore the default for later
 An explicit `gl` override can bring the driver crash back on affected systems. The macOS, Linux
 and web backend defaults are unchanged.
 
+**If the app quits right after its window appears with "Parent device is lost" in the log:**
+WordCraft compiles DirectX 12 shaders with FXC, the compiler built into Windows, so it needs no
+`dxcompiler.dll`/`dxil.dll` and ignores any copy another program put on `PATH` (#603).
+`WGPU_DX12_COMPILER` (`fxc`, `dxc`, `auto`) overrides this; with `dxc`, a matching
+`dxcompiler.dll` *and* `dxil.dll` must sit next to `wordcraft.exe`. `WGPU_BACKEND = "vulkan"`
+also avoids DirectX 12 altogether.
+
 **If the app is slow on an older Windows PC:** when DirectX 12 finds no graphics card with a
 driver for it (for example Intel 4th-generation graphics on Windows 11), it only offers Microsoft's
 software renderer, which draws every frame on the processor. In that case WordCraft uses OpenGL
@@ -260,6 +267,17 @@ instead, without setting anything. The log file records the choice (lines starti
 RISC-V (riscv64): `wordcraft-<ver>-linux-riscv64.tar.gz`, a tarball cross-compiled for glibc 2.39+
 (Ubuntu 24.04, Debian 13 and newer).
 
+**Arch Linux (AUR).** Community members maintain three AUR packages; the project doesn't publish
+to the AUR itself. Install one of them:
+
+| Package | What it installs | Choose it when |
+|---|---|---|
+| [`wordcraft-bin`](https://aur.archlinux.org/packages/wordcraft-bin) | The release tarball above, prebuilt (x86_64, aarch64) | You want the latest release without compiling (quickest) |
+| [`wordcraft`](https://aur.archlinux.org/packages/wordcraft) | The latest release, built from source with `cargo` | You prefer to build releases yourself |
+| [`wordcraft-git`](https://aur.archlinux.org/packages/wordcraft-git) | The current `main` branch, built from source | You want unreleased changes and accept an occasional broken build |
+
+For example `yay -S wordcraft-bin` or `paru -S wordcraft-bin`.
+
 ### FreeBSD
 
 | Build | File |
diff --git a/ROADMAP.md b/ROADMAP.md
index 5a0fbb0d90..82327301e8 100644
--- a/ROADMAP.md
+++ b/ROADMAP.md
@@ -14,7 +14,7 @@ agent control. This page is the summary; the assessment is
 
 | Number | Value | Kind |
 |---|---|---|
-| Ribbon/menu catalog coverage | **429 / 451 (95.1%)** | measured (`cargo xtask parity` → [`docs/parity-checklist.md`](docs/parity-checklist.md)) |
+| Ribbon/menu catalog coverage | **483 / 498 (97.0%)** | measured (`cargo xtask parity` → [`docs/parity-checklist.md`](docs/parity-checklist.md)) |
 | **Feature breadth** (weighted, incl. dialog options, styles, languages beyond the ribbon) | **~80%** | estimated |
 | **Ready for real work** (full target) | **~60%** (55–63%) | estimated, additive weighted sum over the dimensions |
 | **Mainstream practitioner** | **~55%** | estimated: weekly-work depth × discounts for interaction (×0.93), stability (×0.90), file exchange (×0.90) |
@@ -131,8 +131,47 @@ Ranked, to beta (detail and remaining milestones in [docs/roadmap.md](docs/roadm
 ## Progress log
 
 | Date | What landed |
+| 2026-10-11 | Hide White Space (#645): `view.hideWhiteSpace` (View › Show checkbox, or double-click the gap between pages) collapses margins, headers and footers between pages to a thin line in Print Layout; screen only, page count unchanged |
+| 2026-10-11 | Fonts: Palatino Linotype and Book Antiqua fall back to Palatino (macOS) or TeX Gyre Pagella / P052 / URW Palladio (Linux) before generic serif (#670) |
 |---|---|
 | 2026-10-11 | Polish: interface (`pl`, the thirteenth language, every catalog key) and proofing — spelling against the installed Hunspell `pl_PL` dictionary (read at runtime, not bundled) through a new Hunspell-style affix engine, suggestions tuned for Polish, Polish grammar rules with Polish messages, TeX Polish hyphenation patterns (MIT option); proofing language per run (`w:lang`) for squiggles, F7, suggestions and hyphenation, languages without tools left unmarked; Review › Language menu and the status bar's language; a Polish interface writes new documents in Polish |
+| 2026-10-11 | Tables resize with the mouse (#217): drag a column border (the neighbour makes up the difference; Shift moves one column), a row's bottom border, or the handle past the bottom-right corner to scale the table; a dashed guide while dragging, one undo step per drag; `table.resizeDrag` for agents |
+| 2026-10-11 | Animation effects setting: File › Options › Accessibility › Animation effects (Use system setting, On, Off). With the system's animations off (Windows' Animation effects, macOS' Reduce motion, the Linux/BSD desktop's setting, a browser's reduced motion) the page no longer smooth-scrolls: wheel notches and Ctrl+wheel zoom land at once, in the document and in every list and pane, and menus and buttons don't fade; `ui.animations` for agents |
+| 2026-10-11 | Linux/BSD: Open, Save As, Export and Insert Picture work without a file chooser portal or zenity (labwc, sway…): WordCraft shows its own file browser and says how to get the system dialog; File › Open › Browse in WordCraft… is always there (#576) |
+| 2026-10-11 | Every measurement follows File › Options › Advanced › Measurement units (#755): the Line Numbers "From text" distance and the Hyphenation zone, still fixed in inches after #485, now convert like every other dialog |
+| 2026-10-11 | Review › Track Changes Options › Show revisions in balloons: tracked deletions in the body leave the text for "Deleted: …" balloons in the margin, joined to where they were (the option was saved but drew nothing new before) |
+| 2026-10-11 | Security review fixes: `ui.render`/`ui.screenshot` without a `path` (and the MCP bridge's `render_page`/`screenshot`) return the PNG in the reply instead of writing a fixed name into the shared temporary folder; exported HTML/Markdown write `href` only for web, mail, bookmark and relative links, never `javascript:` and other schemes (one allow-list in `wordcraft_doc::link`) |
+| 2026-10-11 | Design tab: the style set gallery gets a box and gaps of its own, so it no longer runs into Colors and Fonts (#638) |
+| 2026-10-11 | File › Print: page preview, page range (all, current, selected, custom 1-3,5), odd/even, copies and collate go into the printed PDF (`file.printPdf`, `ui.print` params); printer, duplex and pages per sheet are still the system dialog's (#641, stage 1) |
+| 2026-10-11 | A vertically merged table cell (eraser on a horizontal border) lays out, shows and clicks as one cell spanning its rows (#640) |
+| 2026-10-11 | Word XML files (#548): Word XML Document (Flat OPC `.xml`) opens and saves through the DOCX reader and writer; Word 2003 XML opens (styles, lists, tables, sections, notes, comments, pictures, hyperlinks) |
+| 2026-10-11 | Font fallback indexes which characters each installed font maps, reading each font file once (#605): text in a script no installed font covers no longer re-reads every system font per distinct character (200 such characters: 13 s → 0.2 s) |
+| 2026-10-11 | Find and Replace special characters (`^p`, `^t`, `^#`, `^&` …) and Use wildcards (ranges, counts, word anchors, groups with `\1` in Replace); `^p` finds and splits paragraphs; Special ▾ menu and search options in the dialog (#543) |
+| 2026-10-11 | Typing parity (#546): `+---+` Enter makes a table, `> ` `-> ` `=> ` arrow bullets, smileys inside words (`ok:)`), Undo right after a border line brings the characters back |
+| 2026-10-11 | Windows: DirectX 12 shaders compile with FXC, built into Windows, so the app no longer quits at launch with "Parent device is lost" when no matching `dxcompiler.dll` + `dxil.dll` pair is around (#603) |
+| 2026-10-11 | Insert › SmartArt (#497): list, process, cycle, hierarchy, pyramid, radial, matrix and Venn graphics laid out by our own code, Text Pane, SmartArt Design tab (Add Shape, Promote, Demote, layouts, colours, Reset); saved as DOCX diagram parts with the drawing. Catalog 410/441 (93.0%) |
+| 2026-10-11 | Outline view (#493): Outlining tab, outline symbols and indents, collapse/expand, Show Level, first line only, plain text; catalog 428/450 → 441/463 (95.2%) |
+| 2026-10-11 | Vertical sections (#491): Layout › Text Direction turns the section (or the cell or text box the caret is in); lines run top to bottom, right to left, ideographs upright; `w:textDirection` in `w:sectPr` read and written |
+| 2026-10-11 | File › Options in Word's panes (#485): General, Display, Proofing, Save, Language, Accessibility, Advanced, Agents; initials, individual formatting marks, spelling ignore options, custom dictionary, overtype, typing replaces selection, measurement units, recent-documents count, print options; `file.options` reads and sets them headlessly |
+| 2026-10-11 | Right-click Wrap Text submenu on pictures, shapes and text boxes: wrapping styles, Move with Text / Fix Position on Page (#513) |
+| 2026-10-11 | Caret animation: keys and typing glide the caret to its new place in 100 ms along the curve measured from Word for Windows, and the blink fades; clicks and scripted moves don't glide. File › Options › Advanced › Animation turns it off, kept between runs; `ui.caretAnimation` for agents |
+| 2026-10-11 | Paragraph dialog options (#512): mirror indents (`w:mirrorIndents`, laid out on even pages), same-style spacing, suppress line numbers, don't hyphenate |
+| 2026-10-11 | Screen readers can read the document canvas (#488): paragraphs, headings, lists, tables, links, pictures and the caret exposed through AccessKit |
+| 2026-10-11 | Add fonts without rebuilding (#582): Home › Font › Add Font… (end of the font list), dropping a TTF/OTF/TTC/WOFF/WOFF2 file, or `font.add`/`font.list`/`font.remove` for agents. Files are checked (50 MB cap, every face must parse and map characters), never replace a bundled or loaded face, and are kept between runs (desktop: `fonts` in the settings folder; web: IndexedDB). Linking a font by URL is still to come |
+| 2026-10-11 | Print Markup (#589): File › Print/Export checkbox, `file.printMarkup`, `markup` on save/export commands and `wordcraft-cli convert --markup` print comments (with replies) in balloons beside each page, scaled to the paper like Word's "Document showing markup"; HTML, Markdown and text copies end with the comments |
+| 2026-10-11 | Custom colours (#606): every colour drop-down gains Recent Colors and More Colors…, which opens a Colors dialog with a Standard honeycomb and a Custom hue/saturation field, lightness slider, RGB/HSL numbers and a hex box |
+| 2026-10-11 | Complex scripts (#604): Myanmar, Khmer and Indic text shaped one script at a time in OpenType fallback fonts (regular weight, not AAT-only fonts), the caret and line breaks never split a syllable, Myanmar wraps between syllables, Backspace removes one sign at a time |
+| 2026-10-11 | Any text file opens (#569): `.m3u`/`.m3u8` playlists and other unknown extensions open as plain text with encoding detection (UTF-8, BOMs, UTF-16, Windows-1252), misnamed Word/RTF files by their signature; binary files give a clear error |
+| 2026-10-11 | Select by dragging whole units (#549): after a double-click the drag grows by words, after a triple-click by paragraphs, after Ctrl/⌘+click by sentences, as in Word |
+| 2026-10-11 | Compare / Combine dialog with comparison settings, Restrict Editing pane (exceptions, SHA-512 password, locked styles; DOCX round trip), AutoCorrect Options dialog saved per user (#412) |
+| 2026-10-11 | DOCX diagrams (#611): lines, connectors and boxes styled by the theme now show (they were invisible); callouts and flowchart boxes drawn as the nearest shape; VML lines, rectangles and ovals |
+| 2026-10-11 | WordArt (#416): text fill/outline/shadow/glow/reflection, Transform warps, our own styles; straight/elbow/curved connectors glued to shapes that re-route; DOCX round trip |
+| 2026-10-11 | Content controls (`w:sdt`) kept, shown and edited; Developer tab, Design Mode, Properties dialog (#381) |
+| 2026-10-11 | Insert › Chart (#409): column, bar, line, area, pie, doughnut and scatter charts with Chart Design (type, Edit Data, title, legend, data labels), saved as real chart parts; catalog 408/439 (92.9%) |
+| 2026-10-11 | Line Numbers, Hyphenation (zone, CAPS, consecutive limit, Manual), Language, Envelopes and Labels dialogs (#407); hyphenation options kept in DOCX; 30 modal dialogs |
+| 2026-10-11 | Accessibility (#386): Alt Text pane for every object and table, Mark as decorative, alt text round-trips in DOCX, deeper checker with fix actions |
+| 2026-10-11 | References dialogs (#402): Caption (labels, chapter numbering), Index and Mark Entry, Custom Table of Contents, Source Manager and Create/Edit Source, with TOC/INDEX/XE/SEQ switches honoured on update |
+| 2026-10-11 | Font dialog: separate Asian text font and Latin text font (#505); `format.font {"eastAsia"}`; East Asian fonts found by the font scan (OS/2 code pages) |
 | 2026-10-11 | Document grid (#391): Page Setup › Document Grid sets lines per page and characters per line (`w:docGrid` round trip); lines snap to the line pitch, East Asian characters to the character pitch; View › Gridlines shows it |
 | 2026-10-11 | Move tracking (#400): `w:moveFrom`/`w:moveTo` and their named ranges kept in DOCX, a tracked cut and paste of a paragraph or sentence records a move, accept/reject at either end resolves both, green double strikethrough/underline and "Moved from/to" balloons |
 | 2026-10-11 | Footnote and Endnote dialog from the References › Footnotes launcher: options per section or document (below text, end of section, number format, start at, restart each section or page), custom marks, convert footnotes ↔ endnotes; kept in DOCX (#385) |
@@ -141,14 +180,18 @@ Ranked, to beta (detail and remaining milestones in [docs/roadmap.md](docs/roadm
 | 2026-10-11 | Insert › Icons (#309): a library of 61 original icons drawn in code, a searchable picker and Icon Color |
 | 2026-10-11 | Home › Font › Enclose Characters (#297): circle, square, triangle or diamond around a character, saved as Word's `EQ \o\ac` field |
 | 2026-10-11 | Phonetic Guide (#288): ruby text over base text, `w:ruby` round trip |
+| 2026-10-12 | Custom XML backing stores preserved as opaque data and related properties through edited DOCX saves; content-control markup is handled by the existing reader/writer and #532 bibliography I/O remains separate; binding evaluation and readiness unchanged |
 | 2026-10-11 | Customize Ribbon and the Quick Access Toolbar: custom tabs and groups, hide and reorder tabs, add or remove toolbar commands (right-click any button, or the toolbar's … menu); kept between runs (#379, #376) |
 | 2026-10-11 | Customize Keyboard: assign, remove and reset keyboard shortcuts; custom keys override built-ins and are kept between runs (#368) |
+| 2026-10-12 | Native saves use exclusively created sibling temporary files, synchronize before replacement and clean up on failure; existing temporary-name files/links and original files on failed saves are protected. Synthetic CLI and focused tests on macOS; no new Word parity or readiness claim. |
 | 2026-10-11 | Field codes like Word's field keys (#339): show codes (Alt+F9, Shift+F9), edit, unlink, lock and step through fields |
 | 2026-10-11 | Word's common keyboard shortcuts (#330): 101 → 125 of ~250 |
 | 2026-10-11 | Turkish (`tr`) interface: all 1,307 catalog entries, `tr-TR`/`tr-CY` system locales and a saved language choice; command search keeps Turkish dotted and dotless I apart (`italik` finds İtalik); locale, catalog, search and bundled-font tests; no Turkish proofing resources |
 | 2026-10-11 | Citations and bibliography in all 12 of Word's styles: Harvard, ISO 690 (author-date and numerical), Turabian, GB/T 7714, GOST (name and title sort) and SIST02 join APA, MLA, Chicago and IEEE; numbered styles count in order of first citation (#383) |
 | 2026-10-11 | Interface size setting (#475): File › Options › General scales the interface 80–200 % on top of the system display scale, kept between runs; `ui.interfaceSize` for agents |
+| 2026-10-11 | DOCX paragraph defaults: preserve omission separately from explicit empty defaults, with repeated-save and default-edit regressions |
 | 2026-10-11 | Formatting revisions (#41): `w:rPrChange`/`w:pPrChange`, table/row/cell, section and numbering changes kept in DOCX; formatting recorded as revisions while tracking; accept/reject, Reviewing Pane descriptions, "Formatted: …" balloons and change bars |
+| 2026-10-11 | Draw: Lasso Select (move, recolour, delete the strokes inside a loop), Add Pen gallery kept between runs, Ink to Shape (own recogniser: line, rectangle/square, ellipse/circle, triangle, polygon), Ink Replay in drawing order with play/pause/rewind/forward; drawing order kept in DOCX (#395); catalog 406/434 (93.5%) |
 | 2026-10-10 | Estonian (`et`) interface (#294): 1,161 translated entries, locale and saved-preference tests, bundled-font checks; no Estonian proofing resources |
 | 2026-10-10 | Draw tab: pen, pencil and highlighter ink, stroke eraser, Select, Review › Hide Ink; ink saved to DOCX as DrawingML freeforms (#307); catalog 399/431 (92.6%) |
 | 2026-10-10 | Draw Table and Eraser (#303): a pen draws one-cell tables and splits cells along drawn lines; the eraser merges the cells beside a border. Catalog 393/431 (91.2%) |
@@ -164,14 +207,37 @@ Ranked, to beta (detail and remaining milestones in [docs/roadmap.md](docs/roadm
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | trivial | Progress log: tables resize with the mouse (#217) |
+| 2026-10-11 | trivial | Progress log: Animation effects setting |
+| 2026-10-11 | trivial | Progress log: built-in file browser when the system file dialog is unavailable (#576) |
+| 2026-10-11 | trivial | Progress log: security review fixes (temp files, exported link schemes) |
+| 2026-10-11 | trivial | Progress log: Find and Replace special characters and wildcards (#543) |
+| 2026-10-11 | trivial | Progress log: Windows DX12 shaders compiled with FXC (#603) |
+| 2026-10-11 | trivial | Progress log: Insert › SmartArt (#497); catalog 429/451 → 437/458 (95.4%) |
+| 2026-10-11 | trivial | Progress log: Outline view (#493) |
+| 2026-10-11 | trivial | Progress log: vertical sections (#491) |
+| 2026-10-11 | trivial | Progress log: Paragraph dialog options, mirror indents (#512) |
+| 2026-10-11 | trivial | Progress log: Print Markup (#589) |
+| 2026-10-11 | trivial | Progress log: custom colours via More Colors… (#606) |
+| 2026-10-11 | trivial | Progress log: complex-script shaping (#604) |
+| 2026-10-11 | trivial | Progress log: unknown text extensions open as text (#569) |
+| 2026-10-11 | trivial | Progress log: drag-select by words/paragraphs/sentences (#549) |
+| 2026-10-11 | trivial | Progress log: content controls (#381) |
+| 2026-10-11 | trivial | Progress log: Insert › Chart (#409); catalog 408/439 (92.9%) |
+| 2026-10-11 | trivial | Progress log: Line Numbers, Hyphenation, Language, Envelopes and Labels dialogs (#407) |
+| 2026-10-11 | trivial | Progress log: Alt Text pane, decorative objects, deeper accessibility checker (#386) |
+| 2026-10-11 | trivial | Progress log: Draw lasso, Add Pen, Ink to Shape, Ink Replay (#395); catalog 406/434 |
 | 2026-10-11 | trivial | Progress log: document grid (#391) |
 | 2026-10-11 | trivial | Progress log: text direction, Align Text and linked text boxes (#369) |
 | 2026-10-10 | trivial | Progress: Drawing Canvas (#344): insert, shapes/pictures/text boxes inside, Fit/Expand/Scale, DOCX `wpc:wpc`, turns and flips as a whole; catalog 404/434 |
 | 2026-10-11 | trivial | Progress log: mail-merge recipients from .xlsx/.xlsm/.ods (#334) |
 | 2026-10-11 | trivial | Insert › Icons landed (#309): catalog 402/434 → 403/434 (92.9%) |
 | 2026-10-11 | trivial | Enclose Characters (#297): catalog 403/434 (92.9%) |
+| 2026-10-12 | minor | Progress log: opaque custom XML store preservation, with synthetic package regressions and explicit limits |
 | 2026-10-11 | trivial | Progress log: Customize Ribbon and the Quick Access Toolbar (#379) |
+| 2026-10-11 | trivial | Omitted `w:pPrDefault` stays omitted across saves; explicit empty/default properties and later spacing edits remain writable. Synthetic preservation checks only; readiness estimates unchanged |
 | 2026-10-11 | trivial | Progress log: Customize Keyboard (#368) |
+| 2026-10-12 | trivial | Native saves protect existing temporary-name entries and originals on pre-replacement failure; synthetic macOS evidence, explicit durability/platform limits; readiness unchanged |
 | 2026-10-11 | trivial | Word's common keyboard shortcuts (#330): 125 of ~250 |
 | 2026-10-11 | trivial | Collapsed duplicate rows left by parallel merges |
 | 2026-10-11 | trivial | Turkish interface (`tr`): progress log and shipped languages |
diff --git a/apps/wordcraft-cli/src/main.rs b/apps/wordcraft-cli/src/main.rs
index 3bd6f73575..d3355ec5eb 100644
--- a/apps/wordcraft-cli/src/main.rs
+++ b/apps/wordcraft-cli/src/main.rs
@@ -12,7 +12,10 @@ const USAGE: &str = "\
 wordcraft-cli — WordCraft from the command line
 
 USAGE:
-  wordcraft-cli convert <in> <out>            convert between formats (docx, doc [read], pdf, odt, rtf, html, md, tex, txt, json, png)
+  wordcraft-cli convert <in> <out> [--markup]
+                                              convert between formats (docx, doc [read], pdf, odt, rtf, html, md, tex, txt, json, png);
+                                              --markup (Print Markup): comments beside each page and
+                                              tracked changes in pdf/png, a comment list in html/md/txt
   wordcraft-cli info <file>                   pages, words, paragraphs, properties (JSON)
   wordcraft-cli text <file>                   plain text
   wordcraft-cli inspect <file>                document structure (JSON)
@@ -74,6 +77,7 @@ fn validate_options(command: &str, args: &[String], specs: &[OptionSpec]) -> Res
 }
 
 const NO_OPTIONS: &[OptionSpec] = &[];
+const CONVERT_OPTIONS: &[OptionSpec] = &[OptionSpec { name: "--markup", takes_value: false }];
 const RENDER_OPTIONS: &[OptionSpec] = &[OptionSpec { name: "--page", takes_value: true }, OptionSpec { name: "--scale", takes_value: true }];
 const RUN_OPTIONS: &[OptionSpec] = &[
     OptionSpec { name: "--file", takes_value: true },
@@ -147,13 +151,14 @@ fn run(args: &[String]) -> Result<(), Failure> {
     let pos = |i: usize| rest.iter().filter(|a| !a.starts_with("--")).nth(i).cloned().ok_or_else(|| format!("missing argument\n\n{USAGE}"));
     match cmd {
         "convert" => {
-            validate_options("convert", &rest, NO_OPTIONS)?;
+            validate_options("convert", &rest, CONVERT_OPTIONS)?;
             let (i, o) = (pos(0)?, pos(1)?);
+            let markup = rest.iter().any(|a| a == "--markup");
             let mut s = open(&i)?;
             let r = if o.to_ascii_lowercase().ends_with(".png") {
-                s.run("file.exportPng", &json!({"path": o, "page": 1}))
+                s.run("file.exportPng", &json!({"path": o, "page": 1, "markup": markup}))
             } else {
-                s.run("file.save", &json!({"path": o}))
+                s.run("file.save", &json!({"path": o, "markup": markup}))
             };
             r.map_err(|e| e.to_string())?;
             eprintln!("wrote {o}");
diff --git a/apps/wordcraft-web/Cargo.toml b/apps/wordcraft-web/Cargo.toml
index befd8b77fb..d9b44aa699 100644
--- a/apps/wordcraft-web/Cargo.toml
+++ b/apps/wordcraft-web/Cargo.toml
@@ -20,6 +20,7 @@ egui = { workspace = true }
 log = { workspace = true }
 serde_json = { workspace = true }
 wordcraft-doc = { workspace = true }
+wordcraft-fonts = { workspace = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 # `wgpu` pulls egui-wgpu's defaults: WebGPU plus the WebGL2 fallback.
@@ -28,4 +29,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", "HtmlAnchorElement", "HtmlIFrameElement", "Blob", "BlobPropertyBag", "Url", "Location", "CssStyleDeclaration", "Event", "EventTarget", "BeforeUnloadEvent", "ClipboardEvent", "DataTransfer", "FileList", "File"] }
+web-sys = { version = "0.3", features = ["Window", "Document", "Element", "HtmlElement", "HtmlCanvasElement", "HtmlAnchorElement", "HtmlIFrameElement", "Blob", "BlobPropertyBag", "Url", "Location", "CssStyleDeclaration", "Event", "EventTarget", "BeforeUnloadEvent", "ClipboardEvent", "DataTransfer", "FileList", "File", "DomStringList", "IdbFactory", "IdbOpenDbRequest", "IdbRequest", "IdbDatabase", "IdbObjectStore", "IdbTransaction", "IdbTransactionMode", "MediaQueryList"] }
diff --git a/apps/wordcraft-web/index.html b/apps/wordcraft-web/index.html
index 83a02c281e..ca6ad46936 100644
--- a/apps/wordcraft-web/index.html
+++ b/apps/wordcraft-web/index.html
@@ -4,6 +4,7 @@
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1, user-scalable=no">
   <title>WordCraft</title>
+  <link data-trunk rel="icon" href="../../assets/app-icon/wordcraft.ico" />
   <link data-trunk rel="rust" data-bin="wordcraft-web" data-wasm-opt="z" data-weak-refs />
   <style>
     html, body { margin: 0; padding: 0; width: 100%; height: 100%; overflow: hidden; background: #e6e6e6; }
diff --git a/apps/wordcraft-web/src/web.rs b/apps/wordcraft-web/src/web.rs
index 5d68374d22..bc5e479876 100644
--- a/apps/wordcraft-web/src/web.rs
+++ b/apps/wordcraft-web/src/web.rs
@@ -8,9 +8,10 @@ use wasm_bindgen::JsCast as _;
 use wordcraft_engine::Session;
 use wordcraft_ui_egui::{Inbox, Services, WordApp};
 
-const DOC_EXTS: &[&str] = &["docx", "docm", "dotx", "dotm", "doc", "dot", "odt", "rtf", "txt", "md", "html", "htm", "tex", "json"];
+const DOC_EXTS: &[&str] = &["docx", "docm", "dotx", "dotm", "doc", "dot", "odt", "rtf", "txt", "md", "html", "htm", "tex", "json", "xml"];
 const IMAGE_EXTS: &[&str] = &["png", "jpg", "jpeg", "gif", "webp", "bmp"];
 const RECIPIENT_EXTS: &[&str] = &["csv", "tsv", "txt", "xlsx", "xlsm", "ods"];
+mod font_store;
 const CANVAS_ID: &str = "wordcraft_canvas";
 const LOADING_ID: &str = "wordcraft_loading";
 
@@ -43,6 +44,8 @@ pub fn start() {
                     if let Some(rs) = &cc.wgpu_render_state {
                         log::info!("wordcraft-web: wgpu backend {:?}", rs.adapter.get_info().backend);
                     }
+                    // Fonts the user added on an earlier visit (#582); the app notices them arrive.
+                    font_store::load_all(cc.egui_ctx.clone());
                     let inbox: Inbox = Inbox::default();
                     if let Err(e) = listen_for_pasted_pictures(inbox.clone(), cc.egui_ctx.clone()) {
                         log::error!("pasting pictures is unavailable: {e}");
@@ -158,6 +161,8 @@ fn services(inbox: Inbox, ctx: egui::Context, dirty: Rc<Cell<bool>>) -> Services
             let ctx = ctx.clone();
             let dialog = if purpose == "picture" {
                 rfd::AsyncFileDialog::new().add_filter("Pictures", IMAGE_EXTS)
+            } else if purpose == "font" {
+                rfd::AsyncFileDialog::new().add_filter("Fonts", wordcraft_fonts::FONT_FILE_EXTS)
             } else if purpose == "recipients" {
                 rfd::AsyncFileDialog::new().add_filter("Recipient lists", RECIPIENT_EXTS)
             } else {
@@ -178,10 +183,21 @@ fn services(inbox: Inbox, ctx: egui::Context, dirty: Rc<Cell<bool>>) -> Services
         print: Some(Box::new(print_pdf)),
         inbox: Some(inbox),
         on_dirty: Some(Box::new(move |d| dirty.set(d))),
+        animations_enabled: Some(animations_enabled()),
+        store_font: Some(Box::new(font_store::store)),
+        forget_font: Some(Box::new(font_store::forget)),
         ..Default::default()
     }
 }
 
+/// Whether the system has animation effects on, as the browser passes it on: off while the
+/// `prefers-reduced-motion: reduce` media query matches. `None` when the browser can't say. The
+/// query is made once and asked every frame; it follows the system's setting by itself.
+fn animations_enabled() -> Box<dyn Fn() -> Option<bool>> {
+    let reduce = web_sys::window().and_then(|w| w.match_media("(prefers-reduced-motion: reduce)").ok().flatten());
+    Box::new(move || reduce.as_ref().map(|query| !query.matches()))
+}
+
 /// Closing, reloading or leaving the tab with unsaved changes asks first. Browsers show their own
 /// confirmation (a page can only ask for it), so there is no Save button: Cancel, then File › Save.
 fn guard_unload(dirty: Rc<Cell<bool>>) -> Result<(), String> {
@@ -306,6 +322,7 @@ fn mime_for(name: &str) -> &'static str {
         Some("md" | "txt") => "text/plain",
         Some("tex") => "application/x-tex",
         Some("json") => "application/json",
+        Some("xml") => "application/xml",
         _ => "application/octet-stream",
     }
 }
diff --git a/apps/wordcraft-web/src/web/font_store.rs b/apps/wordcraft-web/src/web/font_store.rs
new file mode 100644
index 0000000000..3a77264066
--- /dev/null
+++ b/apps/wordcraft-web/src/web/font_store.rs
@@ -0,0 +1,116 @@
+//! Fonts the user added in the browser (#582), kept in IndexedDB (`localStorage` holds about
+//! 5 MB, less than one CJK font) so they are there again after a reload. Every failure is logged
+//! and skipped: a font that can't be stored still works for the session.
+
+use wasm_bindgen::JsCast as _;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::closure::Closure;
+use web_sys::{IdbDatabase, IdbRequest, IdbTransactionMode};
+
+const DB_NAME: &str = "wordcraft";
+const STORE: &str = "fonts";
+
+fn js(e: JsValue) -> String {
+    format!("{e:?}")
+}
+
+/// Wait for an IndexedDB request; its result.
+async fn done(req: &IdbRequest) -> Result<JsValue, String> {
+    let promise = js_sys::Promise::new(&mut |resolve: js_sys::Function, reject: js_sys::Function| {
+        let ok_req = req.clone();
+        let ok = Closure::once_into_js(move || {
+            let _ = resolve.call1(&JsValue::NULL, &ok_req.result().unwrap_or(JsValue::UNDEFINED));
+        });
+        let err = Closure::once_into_js(move || {
+            let _ = reject.call1(&JsValue::NULL, &JsValue::from_str("IndexedDB request failed"));
+        });
+        req.set_onsuccess(Some(ok.unchecked_ref()));
+        req.set_onerror(Some(err.unchecked_ref()));
+    });
+    wasm_bindgen_futures::JsFuture::from(promise).await.map_err(js)
+}
+
+/// The database, with its font store made on first use.
+async fn open() -> Result<IdbDatabase, String> {
+    let factory = web_sys::window().ok_or("no window")?.indexed_db().map_err(js)?.ok_or("IndexedDB is unavailable")?;
+    let req = factory.open_with_u32(DB_NAME, 1).map_err(js)?;
+    let upgrade_req = req.clone();
+    let upgrade = Closure::<dyn FnMut()>::new(move || {
+        if let Ok(db) = upgrade_req.result().and_then(|r| r.dyn_into::<IdbDatabase>().map_err(JsValue::from))
+            && !db.object_store_names().contains(STORE)
+            && let Err(e) = db.create_object_store(STORE)
+        {
+            log::error!("couldn't make the font store: {e:?}");
+        }
+    });
+    req.set_onupgradeneeded(Some(upgrade.as_ref().unchecked_ref()));
+    let db = done(&req).await;
+    req.set_onupgradeneeded(None);
+    drop(upgrade);
+    db?.dyn_into::<IdbDatabase>().map_err(js)
+}
+
+async fn store_async(name: String, bytes: Vec<u8>) -> Result<(), String> {
+    let db = open().await?;
+    let store = db.transaction_with_str_and_mode(STORE, IdbTransactionMode::Readwrite).map_err(js)?.object_store(STORE).map_err(js)?;
+    let req = store.put_with_key(&js_sys::Uint8Array::from(bytes.as_slice()), &JsValue::from_str(&name)).map_err(js)?;
+    done(&req).await.map(|_| ())
+}
+
+async fn forget_async(name: String) -> Result<(), String> {
+    let db = open().await?;
+    let store = db.transaction_with_str_and_mode(STORE, IdbTransactionMode::Readwrite).map_err(js)?.object_store(STORE).map_err(js)?;
+    let req = store.delete(&JsValue::from_str(&name)).map_err(js)?;
+    done(&req).await.map(|_| ())
+}
+
+/// Keep `bytes` (a font file as the user gave it) under `name` (its stored file name).
+pub fn store(name: &str, bytes: &[u8]) {
+    let (name, bytes) = (name.to_string(), bytes.to_vec());
+    wasm_bindgen_futures::spawn_local(async move {
+        if let Err(e) = store_async(name.clone(), bytes).await {
+            log::error!("couldn't keep the font {name} for the next visit: {e}");
+        }
+    });
+}
+
+/// Forget the font stored under `name`.
+pub fn forget(name: &str) {
+    let name = name.to_string();
+    wasm_bindgen_futures::spawn_local(async move {
+        if let Err(e) = forget_async(name.clone()).await {
+            log::error!("couldn't forget the stored font {name}: {e}");
+        }
+    });
+}
+
+/// Add every stored font to the font database (each checked like a new one; one that fails is
+/// logged and skipped), then repaint: the app lays out again when fonts change.
+pub fn load_all(ctx: egui::Context) {
+    wasm_bindgen_futures::spawn_local(async move {
+        let r: Result<(), String> = async {
+            let db = open().await?;
+            let store = db.transaction_with_str(STORE).map_err(js)?.object_store(STORE).map_err(js)?;
+            let keys = done(&store.get_all_keys().map_err(js)?).await?;
+            let values = done(&store.get_all().map_err(js)?).await?;
+            let (keys, values) = (js_sys::Array::from(&keys), js_sys::Array::from(&values));
+            for i in 0..keys.length().min(values.length()) {
+                let Some(name) = keys.get(i).as_string() else { continue };
+                let Ok(bytes) = values.get(i).dyn_into::<js_sys::Uint8Array>() else { continue };
+                if bytes.length() as usize > wordcraft_fonts::MAX_FONT_FILE_BYTES {
+                    log::warn!("stored font {name} is too large; skipped");
+                    continue;
+                }
+                if let Err(e) = wordcraft_fonts::FontDb::global().install_font(&name, &bytes.to_vec()) {
+                    log::warn!("stored font {name} skipped: {e}");
+                }
+            }
+            Ok(())
+        }
+        .await;
+        if let Err(e) = r {
+            log::warn!("no stored fonts: {e}");
+        }
+        ctx.request_repaint();
+    });
+}
diff --git a/apps/wordcraft/Cargo.toml b/apps/wordcraft/Cargo.toml
index 141b569287..d41277f432 100644
--- a/apps/wordcraft/Cargo.toml
+++ b/apps/wordcraft/Cargo.toml
@@ -13,6 +13,8 @@ workspace = true
 [dependencies]
 wordcraft-doc = { workspace = true }
 wordcraft-engine = { workspace = true }
+# Fonts the user added (#582) load from the settings folder at start-up.
+wordcraft-fonts = { workspace = true }
 wordcraft-ui-egui = { workspace = true }
 # The control key file's location (shared with the MCP bridge).
 wordcraft-control-key = { workspace = true }
@@ -31,6 +33,26 @@ winresource = "0.1"
 # by PdfCraft and PhotoCraft) registers the handler (Objective-C interop needs unsafe, which our
 # workspace forbids) behind a safe API. Pinned exactly: review the diff before bumping.
 fmv-macos-events = "=0.1.0"
+# The system's Reduce motion setting (System Settings › Accessibility › Display), read through
+# NSWorkspace: a safe call in these bindings. Already in the build through eframe, rfd and arboard,
+# at this version; this adds only the `NSAccessibility` bindings.
+objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSWorkspace", "NSAccessibility", "NSApplication"] }
+objc2 = "0.6"
+# Closing the window must quit through NSApplication rather than by dropping the NSWindow
+# inside the AppKit run loop (see `schedule_macos_terminate`).
+dispatch2 = "0.3"
+
+[target.'cfg(all(unix, not(target_os = "macos")))'.dependencies]
+# The desktop's animation setting on Linux and the BSDs, read from the XDG settings portal over
+# D-Bus. Already in the build through AccessKit, at this version; this adds only its blocking API.
+zbus = { version = "5", default-features = false, features = ["async-io", "blocking-api"] }
+
+[target.'cfg(target_os = "windows")'.dependencies]
+# The system's Animation effects setting (Settings › Accessibility › Visual effects), read through
+# the Windows Runtime's UISettings: a safe API, where the Win32 call needs unsafe, which our
+# workspace forbids. Already in the build through wgpu and AccessKit, at this version; this adds
+# only the `UI_ViewManagement` bindings.
+windows = { version = "0.62", features = ["UI_ViewManagement"] }
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 rfd = { workspace = true }
diff --git a/apps/wordcraft/src/animations.rs b/apps/wordcraft/src/animations.rs
new file mode 100644
index 0000000000..49cec7099d
--- /dev/null
+++ b/apps/wordcraft/src/animations.rs
@@ -0,0 +1,99 @@
+//! The system's animation setting, which File › Options › Accessibility › Animation effects
+//! follows when set to "Use system setting" (`Services::animations_enabled`).
+//!
+//! - Windows: Settings › Accessibility › Visual effects › Animation effects, read through the
+//!   Windows Runtime's `UISettings`.
+//! - macOS: System Settings › Accessibility › Display › Reduce motion, read through `NSWorkspace`.
+//! - Linux and the BSDs: the desktop's setting, read through the settings portal ([`desktop`]).
+//!
+//! All three are safe APIs of crates already in the build (our workspace forbids unsafe). The UI
+//! asks every frame, so the answer always comes from memory: Windows and macOS are asked again at
+//! most once a second, and the Linux/BSD side keeps its answer up to date on a thread of its own.
+
+#[cfg(any(all(unix, not(target_os = "macos")), test))]
+mod desktop;
+
+/// The answer to "does the system have animation effects on?" for the UI: `None` when the system
+/// doesn't say. `ctx` is asked to redraw when an answer that arrives later changes it.
+pub fn hook(ctx: &egui::Context) -> Box<dyn Fn() -> Option<bool>> {
+    #[cfg(any(target_os = "windows", target_os = "macos"))]
+    {
+        let _ = ctx;
+        Box::new(remembered(system_enabled, REFRESH))
+    }
+    #[cfg(all(unix, not(target_os = "macos")))]
+    {
+        Box::new(desktop::watch(ctx.clone()))
+    }
+    #[cfg(not(any(target_os = "windows", unix)))]
+    {
+        let _ = ctx;
+        Box::new(|| None)
+    }
+}
+
+/// How long an answer from Windows or macOS is kept before the system is asked again.
+#[cfg(any(target_os = "windows", target_os = "macos"))]
+const REFRESH: std::time::Duration = std::time::Duration::from_secs(1);
+
+/// `read`, asked at most once per `every` and answered from memory in between.
+#[cfg(any(target_os = "windows", target_os = "macos", test))]
+fn remembered(read: impl Fn() -> Option<bool>, every: std::time::Duration) -> impl Fn() -> Option<bool> {
+    let last = std::cell::Cell::new(None::<(std::time::Instant, Option<bool>)>);
+    move || {
+        if let Some((at, answer)) = last.get()
+            && at.elapsed() < every
+        {
+            return answer;
+        }
+        let answer = read();
+        last.set(Some((std::time::Instant::now(), answer)));
+        answer
+    }
+}
+
+/// Whether Windows has animation effects on; `None` when it can't be asked.
+#[cfg(target_os = "windows")]
+fn system_enabled() -> Option<bool> {
+    windows::UI::ViewManagement::UISettings::new()
+        .and_then(|settings| settings.AnimationsEnabled())
+        .map_err(|e| log::debug!("system animation setting: {e}"))
+        .ok()
+}
+
+/// Whether macOS plays animations: Reduce motion is off.
+#[cfg(target_os = "macos")]
+fn system_enabled() -> Option<bool> {
+    Some(!objc2_app_kit::NSWorkspace::sharedWorkspace().accessibilityDisplayShouldReduceMotion())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::cell::Cell;
+    use std::time::Duration;
+
+    use super::remembered;
+
+    /// The UI asks every frame; the system is asked once per interval and the answer kept between.
+    #[test]
+    fn the_system_is_asked_once_per_interval() {
+        let asked = Cell::new(0);
+        let system = Cell::new(Some(false));
+        let read = || {
+            asked.set(asked.get() + 1);
+            system.get()
+        };
+        let kept = remembered(read, Duration::from_secs(3600));
+        assert_eq!((kept(), kept(), kept()), (Some(false), Some(false), Some(false)));
+        system.set(Some(true));
+        assert_eq!(kept(), Some(false), "within the interval the remembered answer stands");
+        assert_eq!(asked.get(), 1);
+
+        // Once the interval has passed (here: at once) the system is asked again.
+        let fresh = remembered(read, Duration::ZERO);
+        assert_eq!(fresh(), Some(true));
+        system.set(None);
+        assert_eq!(fresh(), None);
+        assert_eq!(asked.get(), 3);
+    }
+}
diff --git a/apps/wordcraft/src/animations/desktop.rs b/apps/wordcraft/src/animations/desktop.rs
new file mode 100644
index 0000000000..b9999b2afb
--- /dev/null
+++ b/apps/wordcraft/src/animations/desktop.rs
@@ -0,0 +1,305 @@
+//! The desktop's animation setting on Linux and the BSDs.
+//!
+//! Asked of the XDG settings portal over D-Bus (`org.freedesktop.portal.Settings`), which GNOME,
+//! KDE Plasma and the other desktops with a portal answer, inside Flatpak too. Three settings say
+//! whether animations play ([`KEYS`]); any one of them saying no turns them off. Where no portal
+//! answers, or it knows none of the three (a bare window manager), the user's own KDE and GTK
+//! settings files are read instead, once.
+//!
+//! A thread asks at start-up and then follows the portal's change signal, so the UI's question is
+//! always answered from memory and a change in the desktop's settings shows without a restart.
+
+/// What a setting holds, whichever way it was stored.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Reading {
+    Bool(bool),
+    Number(f64),
+    Text(String),
+}
+
+/// A setting as the portal names it: (namespace, key).
+type Key = (&'static str, &'static str);
+
+/// The cross-desktop preference: 1 asks for reduced motion; 0, and values not defined yet, are
+/// no preference.
+const REDUCED_MOTION: Key = ("org.freedesktop.appearance", "reduced-motion");
+/// GNOME's switch, the one GTK follows.
+const GNOME_ANIMATIONS: Key = ("org.gnome.desktop.interface", "enable-animations");
+/// KDE Plasma's animation speed, a factor on every animation's length: 0 makes them instant.
+const KDE_ANIMATION_SPEED: Key = ("org.kde.kdeglobals.KDE", "AnimationDurationFactor");
+
+/// The settings that say whether animations play.
+pub const KEYS: [Key; 3] = [REDUCED_MOTION, GNOME_ANIMATIONS, KDE_ANIMATION_SPEED];
+
+/// Whether animations play according to one of [`KEYS`]; `None` for any other setting, or a
+/// value that isn't one it holds.
+pub fn says(namespace: &str, key: &str, value: &Reading) -> Option<bool> {
+    match (namespace, key) {
+        k if k == REDUCED_MOTION => number(value).map(|n| n != 1.0),
+        k if k == GNOME_ANIMATIONS => truth(value),
+        k if k == KDE_ANIMATION_SPEED => number(value).map(|n| n > 0.0),
+        _ => None,
+    }
+}
+
+fn number(value: &Reading) -> Option<f64> {
+    let n = match value {
+        Reading::Number(n) => *n,
+        Reading::Text(t) => t.trim().parse().ok()?,
+        Reading::Bool(_) => return None,
+    };
+    n.is_finite().then_some(n)
+}
+
+fn truth(value: &Reading) -> Option<bool> {
+    match value {
+        Reading::Bool(b) => Some(*b),
+        Reading::Number(n) => n.is_finite().then_some(*n != 0.0),
+        Reading::Text(t) => match t.trim().to_ascii_lowercase().as_str() {
+            "true" | "1" => Some(true),
+            "false" | "0" => Some(false),
+            _ => None,
+        },
+    }
+}
+
+/// Several settings' answers as one: off as soon as one says off, on when at least one says on,
+/// `None` when none says anything.
+pub fn combine(answers: impl IntoIterator<Item = Option<bool>>) -> Option<bool> {
+    let mut any = None;
+    for on in answers.into_iter().flatten() {
+        if !on {
+            return Some(false);
+        }
+        any = Some(true);
+    }
+    any
+}
+
+/// The value of `key` in `[section]` of a settings file in INI form (KDE's `kdeglobals`, GTK's
+/// `settings.ini`). The last one wins, as the toolkits read it.
+pub fn ini_value<'a>(text: &'a str, section: &str, key: &str) -> Option<&'a str> {
+    let mut inside = false;
+    let mut found = None;
+    for line in text.lines().map(str::trim) {
+        if let Some(name) = line.strip_prefix('[').and_then(|l| l.strip_suffix(']')) {
+            inside = name.trim() == section;
+        } else if inside
+            && !line.starts_with(['#', ';'])
+            && let Some((k, v)) = line.split_once('=')
+            && k.trim() == key
+        {
+            found = Some(v.trim());
+        }
+    }
+    found
+}
+
+/// What the user's own settings files say, given their text (`None` for a file that isn't
+/// there): KDE Plasma's `kdeglobals` and GTK's `settings.ini`s.
+pub fn files_say(kdeglobals: Option<&str>, gtk_settings: [Option<&str>; 2]) -> Option<bool> {
+    let (namespace, key) = KDE_ANIMATION_SPEED;
+    let kde = kdeglobals.and_then(|text| ini_value(text, "KDE", key)).and_then(|v| says(namespace, key, &Reading::Text(v.to_string())));
+    let gtk = gtk_settings
+        .into_iter()
+        .map(|text| text.and_then(|t| ini_value(t, "Settings", "gtk-enable-animations")).and_then(|v| truth(&Reading::Text(v.to_string()))));
+    combine(std::iter::once(kde).chain(gtk))
+}
+
+#[cfg(all(unix, not(target_os = "macos")))]
+pub use watching::watch;
+
+#[cfg(all(unix, not(target_os = "macos")))]
+mod watching {
+    use std::path::{Path, PathBuf};
+    use std::sync::Arc;
+    use std::sync::atomic::{AtomicU8, Ordering};
+
+    use zbus::blocking::{Connection, Proxy};
+    use zbus::zvariant::{OwnedValue, Value};
+
+    use super::{KEYS, Reading, combine, files_say, says};
+
+    // The latest answer, as one byte the UI thread reads without waiting.
+    const UNKNOWN: u8 = 0;
+    const ON: u8 = 1;
+    const OFF: u8 = 2;
+
+    /// Start following the desktop's animation setting. The returned function gives the latest
+    /// answer from memory (`None` until the first one arrives, and when the desktop says nothing);
+    /// `ctx` is asked to redraw when the answer changes.
+    pub fn watch(ctx: egui::Context) -> impl Fn() -> Option<bool> {
+        let latest = Arc::new(AtomicU8::new(UNKNOWN));
+        let shared = latest.clone();
+        let spawned = std::thread::Builder::new().name("animation-setting".into()).spawn(move || {
+            let publish = |answer: Option<bool>| {
+                let code = match answer {
+                    Some(true) => ON,
+                    Some(false) => OFF,
+                    None => UNKNOWN,
+                };
+                if shared.swap(code, Ordering::Relaxed) != code {
+                    ctx.request_repaint();
+                }
+            };
+            if let Err(e) = follow_portal(&publish) {
+                log::debug!("desktop animation setting: no settings portal ({e}); reading the settings files");
+                publish(read_files());
+            }
+        });
+        if let Err(e) = spawned {
+            log::warn!("desktop animation setting: {e}");
+        }
+        move || match latest.load(Ordering::Relaxed) {
+            ON => Some(true),
+            OFF => Some(false),
+            _ => None,
+        }
+    }
+
+    /// Publish what the settings portal says, now and after every change it announces, until the
+    /// connection ends; an error when there is no session bus to ask on. While the portal knows
+    /// none of the settings, the files' answer stands.
+    fn follow_portal(publish: &dyn Fn(Option<bool>)) -> zbus::Result<()> {
+        let connection = Connection::session()?;
+        let portal = Proxy::new(&connection, "org.freedesktop.portal.Desktop", "/org/freedesktop/portal/desktop", "org.freedesktop.portal.Settings")?;
+        // Listen before the first read, so a change between the two isn't missed.
+        let changes = portal.receive_signal("SettingChanged")?;
+        // The files are read once, the first time the portal has nothing to say.
+        let mut files = None;
+        let mut ask = || ask_portal(&portal).or_else(|| *files.get_or_insert_with(read_files));
+        publish(ask());
+        // A setting can turn up later (KDE's has no value while the speed is at its default), so
+        // the changes are followed whatever the portal knew at first. Every setting is asked
+        // again, not just the one announced: KDE announces a new animation speed only as the
+        // cross-desktop preference, and its own setting must not be left at the old value.
+        for change in changes {
+            let ours = change
+                .body()
+                .deserialize::<(String, String, OwnedValue)>()
+                .is_ok_and(|(namespace, key, _)| KEYS.contains(&(namespace.as_str(), key.as_str())));
+            if ours {
+                publish(ask());
+            }
+        }
+        Ok(())
+    }
+
+    /// What the portal's settings come to; `None` when it has none of them.
+    fn ask_portal(portal: &Proxy<'_>) -> Option<bool> {
+        combine(KEYS.map(|(namespace, key)| read_setting(portal, namespace, key).and_then(|value| says(namespace, key, &value))))
+    }
+
+    /// One setting from the portal; `None` when it doesn't have it.
+    fn read_setting(portal: &Proxy<'_>, namespace: &str, key: &str) -> Option<Reading> {
+        // `ReadOne` is the current call; portals from before it only have `Read`.
+        let value: OwnedValue = portal.call("ReadOne", &(namespace, key)).or_else(|_| portal.call("Read", &(namespace, key))).ok()?;
+        reading(&value, 0)
+    }
+
+    fn reading(value: &Value<'_>, depth: u8) -> Option<Reading> {
+        Some(match value {
+            Value::Bool(b) => Reading::Bool(*b),
+            Value::U8(n) => Reading::Number(f64::from(*n)),
+            Value::I16(n) => Reading::Number(f64::from(*n)),
+            Value::U16(n) => Reading::Number(f64::from(*n)),
+            Value::I32(n) => Reading::Number(f64::from(*n)),
+            Value::U32(n) => Reading::Number(f64::from(*n)),
+            Value::I64(n) => Reading::Number(*n as f64),
+            Value::U64(n) => Reading::Number(*n as f64),
+            Value::F64(n) => Reading::Number(*n),
+            Value::Str(s) => Reading::Text(s.as_str().to_string()),
+            // `Read` wraps its answer in a second variant.
+            Value::Value(inner) if depth < 4 => return reading(inner, depth + 1),
+            _ => return None,
+        })
+    }
+
+    /// What the user's settings files say (see [`files_say`]).
+    fn read_files() -> Option<bool> {
+        let config = std::env::var_os("XDG_CONFIG_HOME")
+            .filter(|dir| !dir.is_empty())
+            .map(PathBuf::from)
+            .or_else(|| std::env::var_os("HOME").map(|home| PathBuf::from(home).join(".config")))?;
+        let text = |file: &str| read_capped(&config.join(file));
+        let (kdeglobals, gtk4, gtk3) = (text("kdeglobals"), text("gtk-4.0/settings.ini"), text("gtk-3.0/settings.ini"));
+        files_say(kdeglobals.as_deref(), [gtk4.as_deref(), gtk3.as_deref()])
+    }
+
+    /// A settings file's text: at most 256 KiB of it (they are a few kilobytes).
+    fn read_capped(path: &Path) -> Option<String> {
+        use std::io::Read as _;
+        let mut text = String::new();
+        std::fs::File::open(path).ok()?.take(256 * 1024).read_to_string(&mut text).ok()?;
+        Some(text)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn text(s: &str) -> Reading {
+        Reading::Text(s.to_string())
+    }
+
+    /// Each desktop's setting, as the portal hands it over, comes to animations on or off.
+    #[test]
+    fn each_desktop_setting_says_on_or_off() {
+        let ((appearance, reduced), (gnome, enable), (kde, factor)) = (REDUCED_MOTION, GNOME_ANIMATIONS, KDE_ANIMATION_SPEED);
+        assert_eq!(KEYS, [REDUCED_MOTION, GNOME_ANIMATIONS, KDE_ANIMATION_SPEED]);
+        // The cross-desktop preference: only 1 asks for reduced motion.
+        assert_eq!(says(appearance, reduced, &Reading::Number(1.0)), Some(false));
+        assert_eq!(says(appearance, reduced, &Reading::Number(0.0)), Some(true));
+        assert_eq!(says(appearance, reduced, &Reading::Number(7.0)), Some(true), "a value not defined yet is no preference");
+        assert_eq!(says(appearance, reduced, &Reading::Bool(true)), None);
+        // GNOME's switch.
+        assert_eq!(says(gnome, enable, &Reading::Bool(false)), Some(false));
+        assert_eq!(says(gnome, enable, &Reading::Bool(true)), Some(true));
+        assert_eq!(says(gnome, enable, &text("nonsense")), None);
+        // KDE Plasma's animation speed arrives as text: 0 is instant.
+        assert_eq!(says(kde, factor, &text("0")), Some(false));
+        assert_eq!(says(kde, factor, &text(" 0.5 ")), Some(true));
+        assert_eq!(says(kde, factor, &Reading::Number(1.0)), Some(true));
+        for junk in [text(""), text("fast"), Reading::Number(f64::NAN), text("inf")] {
+            assert_eq!(says(kde, factor, &junk), None, "{junk:?}");
+        }
+        // Any other setting says nothing.
+        assert_eq!(says(gnome, "color-scheme", &Reading::Bool(false)), None);
+        assert_eq!(says("org.example", enable, &Reading::Bool(false)), None);
+    }
+
+    /// One setting saying off is enough; none saying anything is no answer.
+    #[test]
+    fn any_setting_saying_off_turns_animations_off() {
+        assert_eq!(combine([]), None);
+        assert_eq!(combine([None, None]), None);
+        assert_eq!(combine([None, Some(true)]), Some(true));
+        assert_eq!(combine([Some(true), None, Some(false)]), Some(false));
+        assert_eq!(combine([Some(false), Some(true)]), Some(false));
+    }
+
+    /// Without a portal the user's own settings files answer: KDE's animation speed and GTK's
+    /// `gtk-enable-animations`.
+    #[test]
+    fn settings_files_answer_without_a_portal() {
+        let kde_instant = "[General]\nColorScheme=Breeze\n\n[KDE]\nAnimationDurationFactor=0\nSingleClick=false\n";
+        let kde_slow = "[KDE]\nAnimationDurationFactor = 2\n";
+        let gtk_off = "[Settings]\ngtk-theme-name=Adwaita\ngtk-enable-animations=0\n";
+        let gtk_on = "# written by hand\n[Settings]\ngtk-enable-animations=true\n";
+        assert_eq!(files_say(None, [None, None]), None);
+        assert_eq!(files_say(Some("[KDE]\nSingleClick=false\n"), [Some("[Settings]\n"), None]), None, "files that don't mention it");
+        assert_eq!(files_say(Some(kde_instant), [None, None]), Some(false));
+        assert_eq!(files_say(Some(kde_slow), [None, None]), Some(true));
+        assert_eq!(files_say(None, [Some(gtk_off), None]), Some(false));
+        assert_eq!(files_say(None, [None, Some(gtk_on)]), Some(true));
+        assert_eq!(files_say(Some(kde_slow), [Some(gtk_on), Some(gtk_off)]), Some(false), "one file saying off is enough");
+
+        // The key counts only in its own section, comments don't, and the last value wins.
+        assert_eq!(ini_value("[Other]\nAnimationDurationFactor=0\n[KDE]\nSingleClick=true\n", "KDE", "AnimationDurationFactor"), None);
+        assert_eq!(ini_value("[KDE]\n#AnimationDurationFactor=0\n;AnimationDurationFactor=0\n", "KDE", "AnimationDurationFactor"), None);
+        assert_eq!(ini_value("[KDE]\r\nAnimationDurationFactor=0\r\nAnimationDurationFactor=1\r\n", "KDE", "AnimationDurationFactor"), Some("1"));
+        assert_eq!(ini_value("AnimationDurationFactor=0\n", "KDE", "AnimationDurationFactor"), None, "outside any section");
+        assert_eq!(ini_value("", "KDE", "AnimationDurationFactor"), None);
+    }
+}
diff --git a/apps/wordcraft/src/file_dialogs.rs b/apps/wordcraft/src/file_dialogs.rs
index f348b168ab..651cddf4e8 100644
--- a/apps/wordcraft/src/file_dialogs.rs
+++ b/apps/wordcraft/src/file_dialogs.rs
@@ -6,19 +6,25 @@
 //! is queued; the frame (which has the window) builds an `rfd::AsyncFileDialog` parented to the
 //! window, and a background thread waits for the answer, hands it to the app and wakes the UI.
 //!
+//! On Linux and the BSDs rfd asks the xdg-desktop-portal FileChooser and, failing that, runs
+//! `zenity`; with neither (a minimal Wayland compositor such as labwc with only
+//! xdg-desktop-portal-wlr, #576) it answers "cancelled" and nothing ever shows. So the waiting
+//! thread first checks that one of them is there and otherwise answers with an error, and the app
+//! shows its built-in file browser. `WORDCRAFT_FILE_DIALOG=builtin` always uses the built-in one.
+//!
 //! [`Services::file_dialog`]: wordcraft_ui_egui::Services::file_dialog
 
 use std::future::Future;
 use std::pin::Pin;
 use std::sync::mpsc::{Receiver, Sender, channel};
 
-use wordcraft_ui_egui::FileDialogRequest;
+use wordcraft_ui_egui::{FileDialogAnswer, FileDialogRequest};
 
 /// A dialog the app asked for, with the channel its answer goes back through.
-type Request = (FileDialogRequest, Sender<Option<String>>);
+type Request = (FileDialogRequest, Sender<FileDialogAnswer>);
 
 /// The `Services::file_dialog` hook.
-pub type Hook = Box<dyn Fn(FileDialogRequest) -> Receiver<Option<String>>>;
+pub type Hook = Box<dyn Fn(FileDialogRequest) -> Receiver<FileDialogAnswer>>;
 
 /// A picker's answer, waited for off the UI thread.
 type Picking = Pin<Box<dyn Future<Output = Option<rfd::FileHandle>> + Send>>;
@@ -51,11 +57,18 @@ impl Launcher {
             let dialog = rfd::AsyncFileDialog::new().set_parent(parent);
             let picking: Picking = match req {
                 FileDialogRequest::Open { purpose } => Box::pin(open_filters(dialog, &purpose).pick_file()),
-                FileDialogRequest::Save { name } => Box::pin(dialog.set_file_name(name).save_file()),
+                FileDialogRequest::Save { name } => {
+                    let exts = save_exts(&name);
+                    Box::pin(dialog.set_file_name(name).add_filter("Documents", &exts).save_file())
+                }
             };
             let ctx = self.ctx.clone();
             let waiting = std::thread::Builder::new().name("file dialog".into()).spawn(move || {
-                let picked = pollster::block_on(picking).map(|f| f.path().to_string_lossy().to_string());
+                // The picker only starts when first polled: without a system dialog it never does.
+                let picked = match no_system_dialog() {
+                    Some(reason) => Err(reason),
+                    None => Ok(pollster::block_on(picking).map(|f| f.path().to_string_lossy().to_string())),
+                };
                 let _ = answer.send(picked);
                 ctx.request_repaint();
             });
@@ -67,16 +80,102 @@ impl Launcher {
     }
 }
 
-/// The file types Open offers: pictures for Insert/Change Picture, recipient lists for Select
-/// Recipients › Use an Existing List…, documents otherwise.
-fn open_filters(d: rfd::AsyncFileDialog, purpose: &str) -> rfd::AsyncFileDialog {
-    if purpose == "picture" {
-        d.add_filter("Pictures", &["png", "jpg", "jpeg", "gif", "webp", "bmp"])
-    } else if purpose == "recipients" {
-        d.add_filter("Recipient lists", &["csv", "tsv", "txt", "xlsx", "xlsm", "ods"]).add_filter("All files", &["*"])
-    } else {
-        d.add_filter("Documents", &["docx", "docm", "dotx", "dotm", "doc", "dot", "odt", "rtf", "txt", "md", "html", "htm", "tex", "json"])
-            .add_filter("Word document", &["docx"])
-            .add_filter("All files", &["*"])
+/// The file types Open offers (shared with the built-in browser).
+fn open_filters(mut d: rfd::AsyncFileDialog, purpose: &str) -> rfd::AsyncFileDialog {
+    for (name, exts) in wordcraft_ui_egui::open_filters(purpose) {
+        d = d.add_filter(*name, exts);
+    }
+    d
+}
+
+/// Why no system file dialog can be shown, if it can't (#576); run off the UI thread.
+fn no_system_dialog() -> Option<String> {
+    if std::env::var_os("WORDCRAFT_FILE_DIALOG").is_some_and(|v| v == "builtin") {
+        return Some("WORDCRAFT_FILE_DIALOG=builtin".into());
+    }
+    portal_or_zenity_missing()
+}
+
+/// Linux and the BSDs: rfd needs a file chooser portal or zenity. When `dbus-send` can't ask
+/// the session bus, the answer is unknown and rfd gets to try.
+#[cfg(all(unix, not(target_os = "macos")))]
+fn portal_or_zenity_missing() -> Option<String> {
+    if on_path("zenity") {
+        return None;
+    }
+    let portal = std::process::Command::new("dbus-send")
+        .args([
+            "--session",
+            "--print-reply=literal",
+            "--reply-timeout=10000",
+            "--dest=org.freedesktop.portal.Desktop",
+            "/org/freedesktop/portal/desktop",
+            "org.freedesktop.DBus.Properties.Get",
+            "string:org.freedesktop.portal.FileChooser",
+            "string:version",
+        ])
+        .stdin(std::process::Stdio::null())
+        .stdout(std::process::Stdio::null())
+        .stderr(std::process::Stdio::null())
+        .status();
+    match portal {
+        Ok(status) if !status.success() => Some("no xdg-desktop-portal FileChooser on the session bus and no zenity".into()),
+        Ok(_) => None,
+        Err(e) => {
+            log::debug!("couldn't ask D-Bus for the file chooser portal: {e}");
+            None
+        }
+    }
+}
+
+/// Windows and macOS always have their system dialog.
+#[cfg(not(all(unix, not(target_os = "macos"))))]
+fn portal_or_zenity_missing() -> Option<String> {
+    None
+}
+
+/// Whether an executable named `program` is in a `PATH` folder.
+#[cfg(all(unix, not(target_os = "macos")))]
+fn on_path(program: &str) -> bool {
+    std::env::var_os("PATH").is_some_and(|paths| std::env::split_paths(&paths).any(|dir| dir.join(program).is_file()))
+}
+
+/// The file types Save As offers: every format the engine saves, with the suggested name's own
+/// format first. rfd makes a filter's first extension the dialog's default, which the Windows,
+/// macOS and Linux panels append to a file name the user typed without one; with no filter at
+/// all the name came back bare and the save failed, since the format is chosen by extension
+/// (#689).
+fn save_exts(name: &str) -> Vec<String> {
+    let suggested = std::path::Path::new(name)
+        .extension()
+        .and_then(|e| e.to_str())
+        .map(|e| e.to_ascii_lowercase())
+        .filter(|e| wordcraft_engine::io::SAVE_EXTS.contains(&e.as_str()))
+        .unwrap_or_else(|| "docx".to_string());
+    let mut exts: Vec<String> = Vec::with_capacity(wordcraft_engine::io::SAVE_EXTS.len());
+    exts.push(suggested.clone());
+    exts.extend(wordcraft_engine::io::SAVE_EXTS.iter().filter(|e| **e != suggested).map(|e| (*e).to_string()));
+    exts
+}
+
+#[cfg(test)]
+mod tests {
+    use super::save_exts;
+
+    /// #689: the Save dialog's default extension is the suggested name's own format, so a file
+    /// name the user types without one is saved in the document's format instead of coming back
+    /// bare and failing.
+    #[test]
+    fn save_dialog_defaults_to_the_suggested_format() {
+        assert_eq!(save_exts("novel.docx")[0], "docx");
+        assert_eq!(save_exts("report.odt")[0], "odt");
+        assert_eq!(save_exts("annual report.pdf")[0], "pdf");
+        // A suggested name always has an extension; anything unreadable falls back to Word's.
+        assert_eq!(save_exts("no extension")[0], "docx");
+        assert_eq!(save_exts("mystery.rtf2")[0], "docx");
+        // Every savable format is still offered, once.
+        let exts = save_exts("novel.docx");
+        assert!(wordcraft_engine::io::SAVE_EXTS.iter().all(|e| exts.iter().any(|x| x == e)));
+        assert_eq!(exts.len(), wordcraft_engine::io::SAVE_EXTS.len());
     }
 }
diff --git a/apps/wordcraft/src/graphics.rs b/apps/wordcraft/src/graphics.rs
index 85aa433030..3ef5157972 100644
--- a/apps/wordcraft/src/graphics.rs
+++ b/apps/wordcraft/src/graphics.rs
@@ -1,9 +1,10 @@
-//! Windows graphics instance configuration, applied before wgpu can initialize any driver.
+//! Windows graphics instance configuration (backends and the DirectX 12 shader compiler), applied
+//! before wgpu can initialize any driver.
 
 use eframe::{
     NativeOptions,
     egui_wgpu::WgpuSetup,
-    wgpu::{Backends, DeviceType},
+    wgpu::{Backends, DeviceType, Dx12Compiler},
 };
 
 /// What the start-up probe learned about one DirectX 12 adapter.
@@ -55,11 +56,38 @@ pub fn configure_backends(options: &mut NativeOptions, backends: Backends) {
     }
 }
 
+/// The DirectX 12 shader compiler: FXC (`d3dcompiler_47.dll`, part of Windows) unless `env`
+/// (normally `WGPU_DX12_COMPILER`, wgpu's own variable: `fxc`, `dxc`, `auto`…) names another.
+///
+/// #603: wgpu's default (`Auto`) uses DXC, loading whichever `dxcompiler.dll` the DLL search path
+/// finds first. WordCraft ships none, so that copy belongs to another program. Without a matching
+/// `dxil.dll` beside it, DXC warns that the DXIL is unsigned; wgpu takes the warning for a compile
+/// error, its own indirect-validation pipeline fails, the device is lost and eframe exits before
+/// the first frame. FXC is always there and compiles everything egui's shaders need.
+pub fn dx12_compiler(env: Option<&str>) -> Dx12Compiler {
+    let Some(value) = env else { return Dx12Compiler::Fxc };
+    value.parse().unwrap_or_else(|e| {
+        log::warn!("graphics: WGPU_DX12_COMPILER={value:?} ignored ({e}), using FXC");
+        Dx12Compiler::Fxc
+    })
+}
+
+/// Makes the wgpu instance eframe creates compile DirectX 12 shaders with `compiler`.
+pub fn configure_dx12_compiler(options: &mut NativeOptions, compiler: Dx12Compiler) {
+    if let WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup {
+        create.instance_descriptor.backend_options.dx12.shader_compiler = compiler;
+    }
+}
+
 /// Chooses the backends ([`choose_backends`]) and applies them to `options`. Without a
 /// `backend_override` this first probes DirectX 12 with a short-lived instance of its own, which
 /// is dropped before eframe creates the real one.
 #[cfg(target_os = "windows")]
 pub fn configure(options: &mut NativeOptions, backend_override: Option<Backends>) {
+    // First, so the probe's instance doesn't load a stray `dxcompiler.dll` either.
+    let compiler = dx12_compiler(std::env::var("WGPU_DX12_COMPILER").ok().as_deref());
+    log::info!("graphics: DirectX 12 shader compiler {compiler:?}");
+    configure_dx12_compiler(options, compiler);
     let backends = match backend_override {
         Some(backends) => {
             log::info!("graphics: WGPU_BACKEND override, backends {backends:?}");
@@ -87,7 +115,11 @@ fn probe_dx12(options: &NativeOptions) -> Vec<Dx12Adapter> {
     let WgpuSetup::CreateNew(create) = &options.wgpu_options.wgpu_setup else {
         return Vec::new();
     };
-    let instance = Instance::new(InstanceDescriptor { backends: Backends::DX12, ..InstanceDescriptor::new_without_display_handle() });
+    let instance = Instance::new(InstanceDescriptor {
+        backends: Backends::DX12,
+        backend_options: create.instance_descriptor.backend_options.clone(),
+        ..InstanceDescriptor::new_without_display_handle()
+    });
     pollster::block_on(instance.enumerate_adapters(Backends::DX12))
         .iter()
         .map(|adapter| {
@@ -139,6 +171,23 @@ mod tests {
         }
     }
 
+    /// #603: DirectX 12 shaders compile with FXC, never a `dxcompiler.dll` found on the search
+    /// path, unless `WGPU_DX12_COMPILER` asks for it.
+    #[test]
+    fn dx12_compiles_with_fxc_unless_asked() {
+        assert!(matches!(dx12_compiler(None), Dx12Compiler::Fxc));
+        assert!(matches!(dx12_compiler(Some("bogus")), Dx12Compiler::Fxc));
+        assert!(matches!(dx12_compiler(Some("FXC")), Dx12Compiler::Fxc));
+        assert!(matches!(dx12_compiler(Some("dxc")), Dx12Compiler::DynamicDxc { .. }));
+        assert!(matches!(dx12_compiler(Some("auto")), Dx12Compiler::Auto));
+        let mut options = NativeOptions::default();
+        configure_dx12_compiler(&mut options, dx12_compiler(None));
+        let WgpuSetup::CreateNew(create) = options.wgpu_options.wgpu_setup else {
+            panic!("default native options must create a wgpu instance");
+        };
+        assert!(matches!(create.instance_descriptor.backend_options.dx12.shader_compiler, Dx12Compiler::Fxc));
+    }
+
     #[test]
     fn gl_when_dx12_has_no_usable_gpu() {
         // #316: no DirectX 12 driver, so DirectX 12 offers only WARP (or nothing) and lags.
diff --git a/apps/wordcraft/src/main.rs b/apps/wordcraft/src/main.rs
index d825752892..6c392787b7 100644
--- a/apps/wordcraft/src/main.rs
+++ b/apps/wordcraft/src/main.rs
@@ -9,6 +9,7 @@
 #![cfg_attr(all(target_os = "windows", not(debug_assertions)), windows_subsystem = "windows")]
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
+mod animations;
 #[cfg(target_os = "macos")]
 mod apple_events;
 mod control_server;
@@ -48,11 +49,23 @@ impl eframe::App for App {
             ctx.send_viewport_cmd(egui::ViewportCommand::OuterPosition(pos));
         }
         // The window's close button: with unsaved changes, ask first (`WordApp::close_requested`).
-        if ctx.input(|i| i.viewport().close_requested()) && !self.0.close_requested() {
+        let closing = ctx.input(|i| i.viewport().close_requested());
+        if closing && !self.0.close_requested() {
             ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
-        }
-        if self.0.quit_requested {
-            ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+        } else if closing || self.0.quit_requested {
+            // On macOS, letting eframe drop the window inside `-[NSApplication run]` aborts in
+            // `-[_NSTouchBarFinderObservation invalidate]`. Command-Q calls `terminate:`. Once
+            // the close is allowed, take that path instead of dropping the window on this turn.
+            #[cfg(target_os = "macos")]
+            {
+                ctx.send_viewport_cmd(egui::ViewportCommand::CancelClose);
+                self.0.quit_requested = false;
+                schedule_macos_terminate(&self.0, self.2.as_ref());
+            }
+            #[cfg(not(target_os = "macos"))]
+            if self.0.quit_requested {
+                ctx.send_viewport_cmd(egui::ViewportCommand::Close);
+            }
         }
     }
     fn raw_input_hook(&mut self, _ctx: &egui::Context, raw: &mut egui::RawInput) {
@@ -70,6 +83,35 @@ impl eframe::App for App {
     }
 }
 
+/// Quit the way Command-Q does, on the next turn of the main queue.
+///
+/// Called when the window is closing. Doing it on the next turn lets the close
+/// button's display cycle finish while the window still exists; `terminate:`
+/// then ends the process. Preferences are written and the control key file is
+/// removed first, as `on_exit` does, because a fallback [`std::process::exit`]
+/// skips `on_exit`. A second close while a quit is already scheduled is ignored.
+#[cfg(target_os = "macos")]
+fn schedule_macos_terminate(app: &WordApp, key_file: Option<&control_server::KeyFile>) {
+    use std::sync::atomic::{AtomicBool, Ordering};
+    static QUIT: AtomicBool = AtomicBool::new(false);
+    if QUIT.swap(true, Ordering::Relaxed) {
+        return;
+    }
+    log::info!("window close: quitting");
+    save_prefs(app);
+    if let Some(key_file) = key_file {
+        key_file.remove();
+    }
+    dispatch2::DispatchQueue::main().exec_async(|| {
+        if let Some(mtm) = objc2::MainThreadMarker::new() {
+            objc2_app_kit::NSApplication::sharedApplication(mtm).terminate(None);
+        }
+        // `terminate:` does not return when it succeeds. If it did, leave anyway:
+        // staying up after the close was cancelled would trap the user in the window.
+        std::process::exit(0);
+    });
+}
+
 /// `ui.json` in the settings folder, which the MCP bridge also uses to find the control key.
 fn prefs_path() -> Option<std::path::PathBuf> {
     wordcraft_control_key::settings_dir().map(|b| b.join("ui.json"))
@@ -91,19 +133,32 @@ fn load_prefs(app: &mut WordApp) {
     }
     if let Some(p) = prefs_path()
         && let Ok(bytes) = std::fs::read(&p)
-        && let Ok(ui) = serde_json::from_slice::<UiState>(&bytes)
+        && let Some(ui) = UiState::from_json(&bytes)
     {
         app.apply_prefs(ui);
     }
 }
 
+/// Fonts the user added (#582) live in `fonts` in the settings folder: load them, and store fonts
+/// added later there. Runs without preferences neither read nor keep them.
+fn load_user_fonts() {
+    if !prefs_enabled() {
+        return;
+    }
+    let Some(dir) = wordcraft_control_key::settings_dir().map(|d| d.join("fonts")) else { return };
+    let (loaded, skipped) = wordcraft_fonts::FontDb::global().load_user_fonts(&dir);
+    if !loaded.is_empty() || !skipped.is_empty() {
+        log::info!("user fonts: {} loaded, {} skipped from {}", loaded.len(), skipped.len(), dir.display());
+    }
+}
+
 /// The saved window geometry, read before the window opens (`load_prefs` runs after).
 fn saved_window() -> Option<WindowGeometry> {
     if !prefs_enabled() {
         return None;
     }
     let bytes = std::fs::read(prefs_path()?).ok()?;
-    serde_json::from_slice::<UiState>(&bytes).ok()?.window?.sanitized()
+    UiState::from_json(&bytes)?.window?.sanitized()
 }
 
 fn save_prefs(app: &WordApp) {
@@ -121,12 +176,15 @@ fn save_prefs(app: &WordApp) {
 }
 
 /// Native file dialogs, shown without blocking the window (`file_dialogs`, #94), File › Print
-/// through the system's PDF viewer (`print`, #15), and pictures on the system clipboard (#45).
-fn services(file_dialog: file_dialogs::Hook) -> Services {
+/// through the system's PDF viewer (`print`, #15), pictures on the system clipboard (#45), and
+/// the system's animation setting (`animations`).
+fn services(file_dialog: file_dialogs::Hook, ctx: &egui::Context) -> Services {
     Services {
         file_dialog: Some(file_dialog),
         print: Some(print::hook()),
         clipboard_picture: Some(Box::new(clipboard_picture)),
+        animations_enabled: Some(animations::hook(ctx)),
+        clipboard_text: Some(Box::new(|| arboard::Clipboard::new().ok()?.get_text().ok())),
         ..Default::default()
     }
 }
@@ -207,9 +265,11 @@ fn main() -> eframe::Result {
         options.viewport = options.viewport.with_icon(icon);
     }
     // Before eframe creates the wgpu instance: default Windows to DirectX 12 only, or OpenGL when
-    // DirectX 12 has no GPU driver (see graphics.rs).
+    // DirectX 12 has no GPU driver, and compile DirectX 12 shaders with FXC, which needs no
+    // DLL of ours (#603; see graphics.rs).
     #[cfg(target_os = "windows")]
     graphics::configure(&mut options, eframe::wgpu::Backends::from_env());
+    load_user_fonts();
     let restored = saved_window();
     if let Some(window) = restored {
         options.viewport = window.apply(options.viewport);
@@ -226,7 +286,7 @@ fn main() -> eframe::Result {
         Box::new(move |cc| {
             let doc = if sample { wordcraft_engine::sample::sample_document() } else { wordcraft_doc::Document::new() };
             let (file_dialog, dialogs) = file_dialogs::hook(&cc.egui_ctx);
-            let mut app = WordApp::new(Session::new(doc), services(file_dialog));
+            let mut app = WordApp::new(Session::new(doc), services(file_dialog, &cc.egui_ctx));
             load_prefs(&mut app);
             app.ui.window = restored;
             app.integrated_titlebar = cfg!(target_os = "macos");
diff --git a/contributors/people.toml b/contributors/people.toml
index 16c281cca1..d6a5d204aa 100644
--- a/contributors/people.toml
+++ b/contributors/people.toml
@@ -38,5 +38,22 @@ real_name = "Dmitrii Khlapov"
 display_name = "Dima Khlapov"
 sync_github_name = false
 
+[people.arcanii]
+real_name = "Bryan Mark"
+display_name = "Arcanii"
+sync_github_name = false
+
 [people.henno]
 sync_github_name = true
+
+[people.GhostMitra]
+sync_github_name = true
+[people.DevCoderMax]
+real_name = "Gleyson do Nascimento Carvalho"
+display_name = "Gleyson Carvalho"
+sync_github_name = false
+[people.alexanderalber]
+real_name = "Alexander Alber"
+
+[people.edurbs]
+sync_github_name = true
diff --git a/crates/doc/src/chart.rs b/crates/doc/src/chart.rs
new file mode 100644
index 0000000000..6bbfeb8849
--- /dev/null
+++ b/crates/doc/src/chart.rs
@@ -0,0 +1,261 @@
+//! Charts WordCraft makes and edits (Insert › Chart): the chart type, its data (categories and
+//! series), title, legend and data labels.
+//!
+//! A chart object ([`crate::graphic::Graphic`] with `chart` set) keeps this model next to the
+//! items it is drawn with; the DOCX writer turns it into a chart part (`c:chartSpace`) with the
+//! data cached in the part itself, and the reader turns a chart part back into it when the part
+//! holds nothing this model leaves out. Charts from other programs stay as they were read.
+//!
+//! Every value from outside (commands, files) goes through [`ChartSpec::sanitize`]: series,
+//! points and text lengths are capped and values that aren't finite numbers become gaps.
+
+use serde::{Deserialize, Serialize};
+
+/// Most series in a chart.
+pub const MAX_SERIES: usize = 255;
+/// Most categories (points per series) in a chart.
+pub const MAX_POINTS: usize = 4000;
+/// Most cells (series × categories) in a chart: what the chart drawing reads at most.
+pub const MAX_CELLS: usize = 100_000;
+/// Longest title, series name or category label, characters.
+pub const MAX_TEXT: usize = 255;
+
+/// What a chart shows its data as.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum ChartType {
+    /// Clustered columns.
+    #[default]
+    Column,
+    /// Stacked columns.
+    ColumnStacked,
+    /// Clustered horizontal bars.
+    Bar,
+    /// Stacked horizontal bars.
+    BarStacked,
+    Line,
+    Area,
+    Pie,
+    Doughnut,
+    /// XY scatter with markers: the categories are the x values.
+    Scatter,
+}
+
+impl ChartType {
+    pub const ALL: [ChartType; 9] = [
+        ChartType::Column,
+        ChartType::ColumnStacked,
+        ChartType::Bar,
+        ChartType::BarStacked,
+        ChartType::Line,
+        ChartType::Area,
+        ChartType::Pie,
+        ChartType::Doughnut,
+        ChartType::Scatter,
+    ];
+
+    /// The id commands use (`column`, `barStacked`…).
+    pub fn id(self) -> &'static str {
+        match self {
+            ChartType::Column => "column",
+            ChartType::ColumnStacked => "columnStacked",
+            ChartType::Bar => "bar",
+            ChartType::BarStacked => "barStacked",
+            ChartType::Line => "line",
+            ChartType::Area => "area",
+            ChartType::Pie => "pie",
+            ChartType::Doughnut => "doughnut",
+            ChartType::Scatter => "scatter",
+        }
+    }
+
+    /// The type an id names (any ASCII case).
+    pub fn from_id(id: &str) -> Option<ChartType> {
+        ChartType::ALL.into_iter().find(|t| t.id().eq_ignore_ascii_case(id.trim()))
+    }
+
+    /// The name shown for it.
+    pub fn label(self) -> &'static str {
+        match self {
+            ChartType::Column => "Clustered Column",
+            ChartType::ColumnStacked => "Stacked Column",
+            ChartType::Bar => "Clustered Bar",
+            ChartType::BarStacked => "Stacked Bar",
+            ChartType::Line => "Line",
+            ChartType::Area => "Area",
+            ChartType::Pie => "Pie",
+            ChartType::Doughnut => "Doughnut",
+            ChartType::Scatter => "Scatter",
+        }
+    }
+
+    /// Pie and doughnut charts show one series, a slice per category.
+    pub fn is_round(self) -> bool {
+        matches!(self, ChartType::Pie | ChartType::Doughnut)
+    }
+}
+
+/// Where a chart's legend sits.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum LegendPos {
+    Right,
+    Left,
+    Top,
+    #[default]
+    Bottom,
+}
+
+impl LegendPos {
+    pub const ALL: [LegendPos; 4] = [LegendPos::Right, LegendPos::Top, LegendPos::Left, LegendPos::Bottom];
+
+    pub fn id(self) -> &'static str {
+        match self {
+            LegendPos::Right => "right",
+            LegendPos::Left => "left",
+            LegendPos::Top => "top",
+            LegendPos::Bottom => "bottom",
+        }
+    }
+
+    pub fn from_id(id: &str) -> Option<LegendPos> {
+        LegendPos::ALL.into_iter().find(|p| p.id().eq_ignore_ascii_case(id.trim()))
+    }
+}
+
+/// One series: its name and a value per category (`None` = no value, a gap).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ChartSeries {
+    pub name: String,
+    #[serde(default)]
+    pub values: Vec<Option<f64>>,
+}
+
+/// A chart WordCraft can edit.
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ChartSpec {
+    #[serde(rename = "type")]
+    pub kind: ChartType,
+    /// Category labels (scatter charts: the x values).
+    #[serde(default)]
+    pub categories: Vec<String>,
+    #[serde(default)]
+    pub series: Vec<ChartSeries>,
+    #[serde(default)]
+    pub title: Option<String>,
+    /// `None`: no legend.
+    #[serde(default)]
+    pub legend: Option<LegendPos>,
+    /// Show each point's value next to it.
+    #[serde(default)]
+    pub data_labels: bool,
+}
+
+impl ChartSpec {
+    /// A new chart of type `kind` with WordCraft's sample data: four quarters and three series
+    /// (one for pie and doughnut charts, x values for scatter charts), legend at the bottom.
+    pub fn sample(kind: ChartType) -> ChartSpec {
+        let (categories, series): (Vec<&str>, Vec<(&str, [f64; 4])>) = match kind {
+            ChartType::Pie | ChartType::Doughnut => (vec!["North", "East", "South", "West"], vec![("Share", [38.0, 24.0, 21.0, 17.0])]),
+            ChartType::Scatter => (vec!["1", "2", "3", "4"], vec![("Series 1", [2.1, 3.4, 3.0, 4.6]), ("Series 2", [1.2, 1.9, 2.8, 3.1])]),
+            _ => (
+                vec!["Q1", "Q2", "Q3", "Q4"],
+                vec![("Series 1", [3.2, 4.1, 3.6, 5.0]), ("Series 2", [2.0, 2.7, 3.9, 3.3]), ("Series 3", [1.5, 2.2, 2.4, 3.8])],
+            ),
+        };
+        ChartSpec {
+            kind,
+            categories: categories.into_iter().map(str::to_string).collect(),
+            series: series.into_iter().map(|(n, v)| ChartSeries { name: n.to_string(), values: v.into_iter().map(Some).collect() }).collect(),
+            title: None,
+            legend: Some(LegendPos::Bottom),
+            data_labels: false,
+        }
+    }
+
+    /// Number of categories: every series has as many values.
+    pub fn points(&self) -> usize {
+        self.categories.len()
+    }
+
+    /// Make the chart safe to store and draw: text cut to [`MAX_TEXT`] characters with control
+    /// characters turned into spaces and the ends trimmed (an empty title is none); at most
+    /// [`MAX_POINTS`] categories, [`MAX_SERIES`] series and [`MAX_CELLS`] cells; values that
+    /// aren't finite become gaps; every series as long as the categories (padded with gaps,
+    /// categories padded with empty labels to the longest series).
+    pub fn sanitize(&mut self) {
+        self.series.truncate(MAX_SERIES);
+        let longest = self.series.iter().map(|s| s.values.len()).max().unwrap_or(0);
+        let n = self.categories.len().max(longest).min(MAX_POINTS);
+        let keep = MAX_CELLS.checked_div(n).unwrap_or(MAX_SERIES).clamp(1, MAX_SERIES);
+        self.series.truncate(keep);
+        self.categories.truncate(n);
+        for c in &mut self.categories {
+            *c = clean_text(c);
+        }
+        self.categories.resize(n, String::new());
+        for s in &mut self.series {
+            s.name = clean_text(&s.name);
+            s.values.truncate(n);
+            for v in &mut s.values {
+                *v = v.filter(|x| x.is_finite());
+            }
+            s.values.resize(n, None);
+        }
+        self.title = self.title.as_deref().map(clean_text).filter(|t| !t.is_empty());
+    }
+
+    /// The chart after `sanitize`.
+    pub fn sanitized(mut self) -> ChartSpec {
+        self.sanitize();
+        self
+    }
+}
+
+/// `s` as chart text: control characters as spaces, ends trimmed, at most [`MAX_TEXT`] characters.
+pub fn clean_text(s: &str) -> String {
+    let s: String = s.chars().take(MAX_TEXT * 4).map(|c| if c.is_control() { ' ' } else { c }).collect();
+    s.trim().chars().take(MAX_TEXT).collect::<String>().trim_end().to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sanitize_caps_sizes_and_drops_non_finite_values() {
+        let mut c = ChartSpec {
+            categories: vec!["a".into(); MAX_POINTS + 10],
+            series: (0..MAX_SERIES + 5)
+                .map(|i| ChartSeries { name: format!("{}\n{}", "x".repeat(400), i), values: vec![Some(f64::NAN), Some(f64::INFINITY), Some(1.0)] })
+                .collect(),
+            title: Some("  ".into()),
+            ..Default::default()
+        };
+        c.sanitize();
+        assert_eq!(c.points(), MAX_POINTS);
+        assert!(c.series.len() * c.points() <= MAX_CELLS);
+        assert!(!c.series.is_empty());
+        let s = &c.series[0];
+        assert_eq!(s.values.len(), MAX_POINTS);
+        assert_eq!(&s.values[..3], &[None, None, Some(1.0)]);
+        assert_eq!(s.name.chars().count(), MAX_TEXT);
+        assert!(!s.name.contains('\n'));
+        assert_eq!(c.title, None);
+    }
+
+    #[test]
+    fn short_categories_are_padded_to_the_longest_series() {
+        let c = ChartSpec {
+            categories: vec!["a".into()],
+            series: vec![ChartSeries { name: "s".into(), values: vec![Some(1.0), Some(2.0)] }],
+            ..Default::default()
+        }
+        .sanitized();
+        assert_eq!(c.categories, vec!["a".to_string(), String::new()]);
+        assert_eq!(ChartType::from_id("BARSTACKED"), Some(ChartType::BarStacked));
+        assert_eq!(LegendPos::from_id("top"), Some(LegendPos::Top));
+    }
+}
diff --git a/crates/doc/src/cjk_numbers.rs b/crates/doc/src/cjk_numbers.rs
new file mode 100644
index 0000000000..64a1757fa2
--- /dev/null
+++ b/crates/doc/src/cjk_numbers.rs
@@ -0,0 +1,373 @@
+//! East Asian list and page number formats (ECMA-376 §17.18.59 ST_NumberFormat): Chinese,
+//! Japanese and Korean counting systems (with units 十/百/千 and myriads 万/億), legal (financial)
+//! numerals, digit-by-digit ideographs, the heavenly stems and earthly branches, kana and hangul
+//! sequences and enclosed numbers. Written from the number systems' rules; a value outside a
+//! sequence's range falls back to plain decimal.
+
+/// Whether a counting system writes the "one" before a unit.
+#[derive(Clone, Copy, PartialEq, Eq)]
+enum OmitOne {
+    /// Always written: legal numerals (壹拾, 壱百).
+    Never,
+    /// Dropped only before a leading ten: 十, 十一, 十万 but 一百一十 (Chinese).
+    LeadingTen,
+    /// Dropped before 十, 百 and 千 inside every group of four: 十, 百, 千 but 一万 (Japanese,
+    /// Korean).
+    Units,
+}
+
+/// A myriad-based counting system (groups of four digits, like 1|2345|6789).
+struct Counting {
+    /// The digits 1 to 9 (index 0 unused).
+    digits: [char; 10],
+    /// The units ten, hundred, thousand.
+    units: [char; 3],
+    /// The myriads: ten thousand, hundred million.
+    myriads: [char; 2],
+    /// The character written once for a run of zeros between two digits (Chinese 零); `None`
+    /// skips zeros (Japanese, Korean).
+    zero: Option<char>,
+    omit_one: OmitOne,
+}
+
+impl Counting {
+    fn format(&self, n: u32) -> String {
+        if n == 0 {
+            return self.zero.unwrap_or('〇').to_string();
+        }
+        let groups = [n / 100_000_000, (n / 10_000) % 10_000, n % 10_000];
+        let mut out = String::new();
+        let mut zero_pending = false;
+        for (gi, &g) in groups.iter().enumerate() {
+            if g == 0 {
+                zero_pending |= !out.is_empty();
+                continue;
+            }
+            let ds = [g / 1000, (g / 100) % 10, (g / 10) % 10, g % 10];
+            for (pos, &d) in ds.iter().enumerate() {
+                if d == 0 {
+                    zero_pending |= !out.is_empty();
+                    continue;
+                }
+                if zero_pending && let Some(z) = self.zero {
+                    out.push(z);
+                }
+                zero_pending = false;
+                // pos 0 = thousands, 1 = hundreds, 2 = tens, 3 = ones.
+                let unit = match pos {
+                    0 => self.units.get(2),
+                    1 => self.units.get(1),
+                    2 => self.units.first(),
+                    _ => None,
+                };
+                let omit = d == 1
+                    && unit.is_some()
+                    && match self.omit_one {
+                        OmitOne::Never => false,
+                        OmitOne::LeadingTen => pos == 2 && out.is_empty(),
+                        OmitOne::Units => true,
+                    };
+                if !omit {
+                    out.push(self.digits.get(d as usize).copied().unwrap_or('?'));
+                }
+                if let Some(&u) = unit {
+                    out.push(u);
+                }
+            }
+            match gi {
+                0 => out.extend(self.myriads.get(1)),
+                1 => out.extend(self.myriads.first()),
+                _ => {}
+            }
+        }
+        out
+    }
+}
+
+const CN_DIGITS: [char; 10] = ['〇', '一', '二', '三', '四', '五', '六', '七', '八', '九'];
+
+const CHINESE: Counting =
+    Counting { digits: CN_DIGITS, units: ['十', '百', '千'], myriads: ['万', '亿'], zero: Some('零'), omit_one: OmitOne::LeadingTen };
+const TAIWANESE: Counting =
+    Counting { digits: CN_DIGITS, units: ['十', '百', '千'], myriads: ['萬', '億'], zero: Some('零'), omit_one: OmitOne::LeadingTen };
+const CHINESE_LEGAL: Counting = Counting {
+    digits: ['零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'],
+    units: ['拾', '佰', '仟'],
+    myriads: ['万', '亿'],
+    zero: Some('零'),
+    omit_one: OmitOne::Never,
+};
+const TRADITIONAL_LEGAL: Counting = Counting {
+    digits: ['零', '壹', '貳', '參', '肆', '伍', '陸', '柒', '捌', '玖'],
+    units: ['拾', '佰', '仟'],
+    myriads: ['萬', '億'],
+    zero: Some('零'),
+    omit_one: OmitOne::Never,
+};
+const JAPANESE: Counting =
+    Counting { digits: CN_DIGITS, units: ['十', '百', '千'], myriads: ['万', '億'], zero: None, omit_one: OmitOne::Units };
+const JAPANESE_LEGAL: Counting = Counting {
+    digits: ['〇', '壱', '弐', '参', '四', '伍', '六', '七', '八', '九'],
+    units: ['拾', '百', '阡'],
+    myriads: ['萬', '億'],
+    zero: None,
+    omit_one: OmitOne::Never,
+};
+const KOREAN: Counting = Counting {
+    digits: ['영', '일', '이', '삼', '사', '오', '육', '칠', '팔', '구'],
+    units: ['십', '백', '천'],
+    myriads: ['만', '억'],
+    zero: None,
+    omit_one: OmitOne::Units,
+};
+
+/// 一, 二 … 十, 十一 … 九十九 (Chinese counting); from 100 on, digit by digit (一〇〇).
+pub(crate) fn chinese_counting(n: u32) -> String {
+    if n < 100 { CHINESE.format(n) } else { digits(n, &CN_DIGITS) }
+}
+
+/// Chinese counting with every unit: 一百零一, 一千, 一万.
+pub(crate) fn chinese_counting_thousand(n: u32) -> String {
+    CHINESE.format(n)
+}
+
+/// Simplified Chinese legal (financial) numerals: 壹, 贰, 叁 … 壹拾.
+pub(crate) fn chinese_legal_simplified(n: u32) -> String {
+    CHINESE_LEGAL.format(n)
+}
+
+/// Traditional Chinese legal numerals: 壹, 貳, 參 … 壹拾.
+pub(crate) fn ideograph_legal_traditional(n: u32) -> String {
+    TRADITIONAL_LEGAL.format(n)
+}
+
+/// Taiwanese counting: like Chinese counting below 100, digit by digit above.
+pub(crate) fn taiwanese_counting(n: u32) -> String {
+    if n < 100 { TAIWANESE.format(n) } else { digits(n, &CN_DIGITS) }
+}
+
+/// Taiwanese counting with every unit: 一百零一, 一千, 一萬.
+pub(crate) fn taiwanese_counting_thousand(n: u32) -> String {
+    TAIWANESE.format(n)
+}
+
+/// Japanese counting: 一 … 十, 十一, 百, 千, 一万.
+pub(crate) fn japanese_counting(n: u32) -> String {
+    JAPANESE.format(n)
+}
+
+/// Japanese legal numerals: 壱, 弐, 参 … 壱拾.
+pub(crate) fn japanese_legal(n: u32) -> String {
+    JAPANESE_LEGAL.format(n)
+}
+
+/// Japanese digits with 万/億 marking each group of four: 一二, 一万二三四五.
+pub(crate) fn japanese_digital_ten_thousand(n: u32) -> String {
+    let groups = [(n / 100_000_000, Some('億')), ((n / 10_000) % 10_000, Some('万')), (n % 10_000, None)];
+    let mut out = String::new();
+    for (g, mark) in groups {
+        let s = digits(g, &CN_DIGITS);
+        if out.is_empty() {
+            if g == 0 && mark.is_some() {
+                continue;
+            }
+        } else {
+            // Inner groups keep their four places: 一万〇〇〇一.
+            out.extend(std::iter::repeat_n('〇', 4usize.saturating_sub(s.chars().count())));
+        }
+        out.push_str(&s);
+        out.extend(mark);
+    }
+    out
+}
+
+/// Sino-Korean numbers in hangul: 일, 이, 삼 … 십, 십일, 백.
+pub(crate) fn korean_counting(n: u32) -> String {
+    KOREAN.format(n)
+}
+
+/// Sino-Korean digits in hangul, one per digit: 일, 일영, 일일.
+pub(crate) fn korean_digital(n: u32) -> String {
+    digits(n, &KOREAN.digits)
+}
+
+const KO_ONES: [&str; 10] = ["", "하나", "둘", "셋", "넷", "다섯", "여섯", "일곱", "여덟", "아홉"];
+const KO_TENS: [&str; 10] = ["", "열", "스물", "서른", "마흔", "쉰", "예순", "일흔", "여든", "아흔"];
+
+/// Native Korean numbers: 하나, 둘, 셋 … 열, 열하나 … 아흔아홉 (decimal from 100 on).
+pub(crate) fn korean_legal(n: u32) -> String {
+    if n == 0 || n > 99 {
+        return n.to_string();
+    }
+    let (t, o) = ((n / 10) as usize, (n % 10) as usize);
+    format!("{}{}", KO_TENS.get(t).copied().unwrap_or(""), KO_ONES.get(o).copied().unwrap_or(""))
+}
+
+/// One ideograph per decimal digit: 一, 一〇, 一〇一.
+pub(crate) fn ideograph_digital(n: u32) -> String {
+    digits(n, &CN_DIGITS)
+}
+
+fn digits(n: u32, set: &[char; 10]) -> String {
+    n.to_string().bytes().map(|b| set.get(b.saturating_sub(b'0') as usize).copied().unwrap_or('?')).collect()
+}
+
+const STEMS: [char; 10] = ['甲', '乙', '丙', '丁', '戊', '己', '庚', '辛', '壬', '癸'];
+const BRANCHES: [char; 12] = ['子', '丑', '寅', '卯', '辰', '巳', '午', '未', '申', '酉', '戌', '亥'];
+
+/// The ten heavenly stems: 甲, 乙, 丙 … 癸.
+pub(crate) fn ideograph_traditional(n: u32) -> String {
+    nth(&STEMS, n)
+}
+
+/// The twelve earthly branches: 子, 丑, 寅 … 亥.
+pub(crate) fn ideograph_zodiac(n: u32) -> String {
+    nth(&BRANCHES, n)
+}
+
+/// The sixty-year cycle: 甲子, 乙丑, 丙寅 … 癸亥.
+pub(crate) fn ideograph_zodiac_traditional(n: u32) -> String {
+    if !(1..=60).contains(&n) {
+        return n.to_string();
+    }
+    let i = (n - 1) as usize;
+    [STEMS.get(i % 10), BRANCHES.get(i % 12)].into_iter().flatten().collect()
+}
+
+/// The `n`th (1-based) item of a sequence, or decimal past its end.
+fn nth(set: &[char], n: u32) -> String {
+    n.checked_sub(1).and_then(|i| set.get(i as usize)).map(|c| c.to_string()).unwrap_or_else(|| n.to_string())
+}
+
+/// Code points `first..` enclosing 1 to `count`, decimal beyond.
+fn enclosed(n: u32, first: u32, count: u32) -> String {
+    if (1..=count).contains(&n)
+        && let Some(c) = char::from_u32(first + n - 1)
+    {
+        return c.to_string();
+    }
+    n.to_string()
+}
+
+/// ① ② ③ … ⑳.
+pub(crate) fn decimal_enclosed_circle(n: u32) -> String {
+    enclosed(n, 0x2460, 20)
+}
+
+/// ① … ⑩ (the Chinese set stops at ten).
+pub(crate) fn decimal_enclosed_circle_chinese(n: u32) -> String {
+    enclosed(n, 0x2460, 10)
+}
+
+/// ⒈ ⒉ ⒊ … ⒛.
+pub(crate) fn decimal_enclosed_fullstop(n: u32) -> String {
+    enclosed(n, 0x2488, 20)
+}
+
+/// ⑴ ⑵ ⑶ … ⒇.
+pub(crate) fn decimal_enclosed_paren(n: u32) -> String {
+    enclosed(n, 0x2474, 20)
+}
+
+/// ㊀ ㊁ ㊂ … ㊉ (circled ideographs).
+pub(crate) fn ideograph_enclosed_circle(n: u32) -> String {
+    enclosed(n, 0x3280, 10)
+}
+
+/// Full-width digits: １, ２ … １０.
+pub(crate) fn decimal_full_width(n: u32) -> String {
+    n.to_string().chars().map(|c| c.to_digit(10).and_then(|d| char::from_u32(0xFF10 + d)).unwrap_or(c)).collect()
+}
+
+const AIUEO: &str = "アイウエオカキクケコサシスセソタチツテトナニヌネノハヒフヘホマミムメモヤユヨラリルレロワヲン";
+const AIUEO_HALF: &str = "ｱｲｳｴｵｶｷｸｹｺｻｼｽｾｿﾀﾁﾂﾃﾄﾅﾆﾇﾈﾉﾊﾋﾌﾍﾎﾏﾐﾑﾒﾓﾔﾕﾖﾗﾘﾙﾚﾛﾜｦﾝ";
+const IROHA: &str = "イロハニホヘトチリヌルヲワカヨタレソツネナラムウヰノオクヤマケフコエテアサキユメミシヱヒモセス";
+const IROHA_HALF: &str = "ｲﾛﾊﾆﾎﾍﾄﾁﾘﾇﾙｦﾜｶﾖﾀﾚｿﾂﾈﾅﾗﾑｳヰﾉｵｸﾔﾏｹﾌｺｴﾃｱｻｷﾕﾒﾐｼヱﾋﾓｾｽ";
+const GANADA: &str = "가나다라마바사아자차카타파하";
+const CHOSUNG: &str = "ㄱㄴㄷㄹㅁㅂㅅㅇㅈㅊㅋㅌㅍㅎ";
+
+fn nth_of(set: &str, n: u32) -> String {
+    n.checked_sub(1).and_then(|i| set.chars().nth(i as usize)).map(|c| c.to_string()).unwrap_or_else(|| n.to_string())
+}
+
+/// Half-width katakana in gojūon order: ｱ, ｲ, ｳ …
+pub(crate) fn aiueo(n: u32) -> String {
+    nth_of(AIUEO_HALF, n)
+}
+
+/// Full-width katakana in gojūon order: ア, イ, ウ …
+pub(crate) fn aiueo_full_width(n: u32) -> String {
+    nth_of(AIUEO, n)
+}
+
+/// Half-width katakana in iroha order: ｲ, ﾛ, ﾊ …
+pub(crate) fn iroha(n: u32) -> String {
+    nth_of(IROHA_HALF, n)
+}
+
+/// Full-width katakana in iroha order: イ, ロ, ハ …
+pub(crate) fn iroha_full_width(n: u32) -> String {
+    nth_of(IROHA, n)
+}
+
+/// Hangul syllables: 가, 나, 다 …
+pub(crate) fn ganada(n: u32) -> String {
+    nth_of(GANADA, n)
+}
+
+/// Hangul initial consonants: ㄱ, ㄴ, ㄷ …
+pub(crate) fn chosung(n: u32) -> String {
+    nth_of(CHOSUNG, n)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn chinese_counting_systems() {
+        let c = |n| chinese_counting(n);
+        assert_eq!([c(1), c(2), c(3), c(10), c(11), c(20), c(21), c(99)], ["一", "二", "三", "十", "十一", "二十", "二十一", "九十九"]);
+        assert_eq!([c(100), c(101), c(1000)], ["一〇〇", "一〇一", "一〇〇〇"]);
+        let t = |n| chinese_counting_thousand(n);
+        assert_eq!(
+            [t(10), t(11), t(20), t(101), t(110), t(111), t(1000), t(1010)],
+            ["十", "十一", "二十", "一百零一", "一百一十", "一百一十一", "一千", "一千零一十"]
+        );
+        assert_eq!([t(10_000), t(10_001), t(100_100), t(1_000_000), t(100_000_001)], ["一万", "一万零一", "十万零一百", "一百万", "一亿零一"]);
+        assert_eq!(t(u32::MAX), "四十二亿九千四百九十六万七千二百九十五");
+        let l = |n| chinese_legal_simplified(n);
+        assert_eq!([l(1), l(3), l(10), l(11), l(101), l(1000)], ["壹", "叁", "壹拾", "壹拾壹", "壹佰零壹", "壹仟"]);
+        assert_eq!([taiwanese_counting_thousand(10_001), ideograph_legal_traditional(20)], ["一萬零一", "貳拾"]);
+        assert_eq!([ideograph_digital(10), ideograph_digital(101)], ["一〇", "一〇一"]);
+    }
+
+    #[test]
+    fn japanese_and_korean() {
+        let j = |n| japanese_counting(n);
+        assert_eq!([j(10), j(11), j(20), j(101), j(1000), j(10_000), j(10_001)], ["十", "十一", "二十", "百一", "千", "一万", "一万一"]);
+        assert_eq!([japanese_legal(10), japanese_legal(1000)], ["壱拾", "壱阡"]);
+        let d = |n| japanese_digital_ten_thousand(n);
+        assert_eq!([d(12), d(10_000), d(12_345), d(100_000_000)], ["一二", "一万〇〇〇〇", "一万二三四五", "一億〇〇〇〇万〇〇〇〇"]);
+        assert_eq!([korean_counting(11), korean_counting(20), korean_counting(101)], ["십일", "이십", "백일"]);
+        assert_eq!(
+            [korean_digital(10), korean_legal(1), korean_legal(11), korean_legal(20), korean_legal(100)],
+            ["일영", "하나", "열하나", "스물", "100"]
+        );
+    }
+
+    #[test]
+    fn sequences_and_enclosed_numbers() {
+        assert_eq!([ideograph_traditional(1), ideograph_traditional(10), ideograph_traditional(11)], ["甲", "癸", "11"]);
+        assert_eq!([ideograph_zodiac(1), ideograph_zodiac(12), ideograph_zodiac(13)], ["子", "亥", "13"]);
+        assert_eq!([ideograph_zodiac_traditional(1), ideograph_zodiac_traditional(11), ideograph_zodiac_traditional(60)], ["甲子", "甲戌", "癸亥"]);
+        assert_eq!([decimal_enclosed_circle(1), decimal_enclosed_circle(20), decimal_enclosed_circle(21)], ["①", "⑳", "21"]);
+        assert_eq!([decimal_enclosed_circle_chinese(10), decimal_enclosed_circle_chinese(11)], ["⑩", "11"]);
+        assert_eq!([decimal_enclosed_fullstop(1), decimal_enclosed_paren(20), ideograph_enclosed_circle(1)], ["⒈", "⒇", "㊀"]);
+        assert_eq!(decimal_full_width(10), "１０");
+        assert_eq!([aiueo_full_width(1), aiueo_full_width(46), aiueo_full_width(47), aiueo(2)], ["ア", "ン", "47", "ｲ"]);
+        assert_eq!([iroha_full_width(1), iroha_full_width(47), iroha(3)], ["イ", "ス", "ﾊ"]);
+        assert_eq!([ganada(1), chosung(14), ganada(0)], ["가", "ㅎ", "0"]);
+        assert_eq!([AIUEO.chars().count(), AIUEO_HALF.chars().count(), IROHA.chars().count(), IROHA_HALF.chars().count()], [46, 46, 47, 47]);
+    }
+}
diff --git a/crates/doc/src/cluster.rs b/crates/doc/src/cluster.rs
new file mode 100644
index 0000000000..b41a8fcc41
--- /dev/null
+++ b/crates/doc/src/cluster.rs
@@ -0,0 +1,236 @@
+//! Text clusters for complex scripts (Myanmar, Khmer, Tai Tham, the Indic scripts): where the
+//! caret may stop, what Backspace removes, and where Myanmar text may wrap.
+//!
+//! Extended grapheme clusters (UAX #29) split some syllables that a shaper draws as one unit: a
+//! Myanmar consonant stacked under a virama (`မ္ဘ`), the Myanmar vowel signs U+102B/U+102C and
+//! the visarga U+1038 (excluded from the grapheme `SpacingMark` class), Khmer subscript
+//! consonants after the coeng. A caret between those would sit inside a glyph cluster, so the
+//! caret steps and layout clusters both use [`joins_cluster`] on top of the grapheme rules.
+
+use unicode_segmentation::UnicodeSegmentation;
+
+/// Invisible stackers: the next consonant is drawn under this one (Myanmar virama, Khmer coeng,
+/// Tai Tham sakot).
+fn is_stacker(c: char) -> bool {
+    matches!(u32::from(c), 0x1039 | 0x17D2 | 0x1A60)
+}
+
+/// Dependent vowel signs, medials, tone marks and other combining signs of Myanmar, Khmer and
+/// Tai Tham: never the start of a cluster.
+fn is_dependent(c: char) -> bool {
+    matches!(u32::from(c),
+        0x102B..=0x103E
+        | 0x1056..=0x1059
+        | 0x105E..=0x1060
+        | 0x1062..=0x1064
+        | 0x1067..=0x106D
+        | 0x1071..=0x1074
+        | 0x1082..=0x108D
+        | 0x108F
+        | 0x109A..=0x109D
+        | 0xA9E5
+        | 0xAA7B..=0xAA7D
+        | 0x17B4..=0x17D1
+        | 0x17D3
+        | 0x17DD
+        | 0x1A55..=0x1A5E
+        | 0x1A61..=0x1A7C
+        | 0x1A7F)
+}
+
+/// No caret stop between `prev` and `next` although a grapheme boundary falls there: `next` is a
+/// sign that belongs to the syllable before it, or `prev` stacks the next consonant.
+pub fn joins_cluster(prev: char, next: char) -> bool {
+    is_stacker(prev) || is_dependent(next)
+}
+
+/// Is `off` a cluster boundary of `text` (0 and `text.len()` always are)?
+pub fn is_cluster_boundary(text: &str, off: usize) -> bool {
+    if off == 0 || off >= text.len() {
+        return true;
+    }
+    if !text.is_char_boundary(off) {
+        return false;
+    }
+    let mut g = unicode_segmentation::GraphemeCursor::new(off, text.len(), true);
+    if !g.is_boundary(text, 0).unwrap_or(true) {
+        return false;
+    }
+    let prev = text.get(..off).and_then(|t| t.chars().next_back());
+    let next = text.get(off..).and_then(|t| t.chars().next());
+    !matches!((prev, next), (Some(p), Some(n)) if joins_cluster(p, n))
+}
+
+/// Byte offsets where clusters start (graphemes, joined per [`joins_cluster`]), in order; the
+/// first is 0 for non-empty text.
+pub fn cluster_starts(text: &str) -> Vec<usize> {
+    let mut out: Vec<usize> = Vec::new();
+    let mut prev: Option<char> = None;
+    for (i, g) in text.grapheme_indices(true) {
+        let first = g.chars().next();
+        let joined = matches!((prev, first), (Some(p), Some(n)) if joins_cluster(p, n));
+        if !joined {
+            out.push(i);
+        }
+        prev = g.chars().next_back();
+    }
+    out
+}
+
+/// `off` clamped to `text` and moved back to a character boundary.
+fn char_floor(text: &str, off: usize) -> usize {
+    let mut o = off.min(text.len());
+    while o > 0 && !text.is_char_boundary(o) {
+        o -= 1;
+    }
+    o
+}
+
+/// The previous cluster boundary before `off` (0 at the start).
+pub fn prev_cluster(text: &str, off: usize) -> usize {
+    let mut off = char_floor(text, off);
+    loop {
+        let mut c = unicode_segmentation::GraphemeCursor::new(off, text.len(), true);
+        off = c.prev_boundary(text, 0).ok().flatten().unwrap_or(0);
+        if is_cluster_boundary(text, off) {
+            return off;
+        }
+    }
+}
+
+/// The next cluster boundary after `off` (`text.len()` at the end).
+pub fn next_cluster(text: &str, off: usize) -> usize {
+    let mut off = char_floor(text, off);
+    loop {
+        let mut c = unicode_segmentation::GraphemeCursor::new(off, text.len(), true);
+        off = c.next_boundary(text, 0).ok().flatten().unwrap_or(text.len());
+        if is_cluster_boundary(text, off) {
+            return off;
+        }
+    }
+}
+
+/// Scripts whose Backspace removes one character at a time (a vowel sign, a medial, a stacked
+/// consonant) rather than the whole cluster, as on Windows and macOS: the Brahmic scripts of
+/// South and South-East Asia.
+pub fn backspaces_by_char(c: char) -> bool {
+    matches!(u32::from(c),
+        0x0900..=0x0DFF // Devanagari … Sinhala
+        | 0x0E00..=0x0EFF // Thai, Lao
+        | 0x0F00..=0x0FFF // Tibetan
+        | 0x1000..=0x109F // Myanmar
+        | 0x1780..=0x17FF // Khmer
+        | 0x1A20..=0x1AAF // Tai Tham
+        | 0x1B00..=0x1B7F // Balinese
+        | 0xA980..=0xA9FF // Javanese, Myanmar Extended-B
+        | 0xAA60..=0xAA7F) // Myanmar Extended-A
+}
+
+/// A Myanmar character that starts a syllable: a consonant (with the Mon, Shan and Karen ones),
+/// an independent vowel, the great sa.
+fn myanmar_syllable_start(c: char) -> bool {
+    matches!(u32::from(c), 0x1000..=0x102A | 0x103F | 0x1050..=0x1055 | 0x105A..=0x105D | 0x1061 | 0x1065..=0x1066 | 0x106E..=0x1070 | 0x1075..=0x1081 | 0x108E)
+}
+
+/// Line-break opportunities inside Myanmar text, which has no spaces between words: before each
+/// syllable (UAX #14 leaves class SA to a dictionary; Word breaks Myanmar between syllables). A
+/// consonant starts a syllable unless it is stacked (after U+1039) or a final (followed, perhaps
+/// after a medial, by the asat U+103A, the virama U+1039 or the dot below U+1037). Byte offsets,
+/// sorted; only between two Myanmar characters.
+pub fn myanmar_breaks(text: &str) -> Vec<usize> {
+    let chars: Vec<(usize, char)> = text.char_indices().collect();
+    let myanmar = |c: char| matches!(u32::from(c), 0x1000..=0x109F | 0xA9E0..=0xA9FF | 0xAA60..=0xAA7F);
+    let mut out = Vec::new();
+    for k in 1..chars.len() {
+        let (Some(&(i, c)), Some(&(_, prev))) = (chars.get(k), chars.get(k - 1)) else { continue };
+        if !myanmar(prev) || !myanmar_syllable_start(c) || is_stacker(prev) {
+            continue;
+        }
+        // Skip one medial ya/ha, then look for a killer.
+        let mut j = k + 1;
+        if chars.get(j).is_some_and(|&(_, n)| matches!(n, '\u{103B}' | '\u{103E}')) {
+            j += 1;
+        }
+        if chars.get(j).is_some_and(|&(_, n)| matches!(n, '\u{1037}' | '\u{1039}' | '\u{103A}')) {
+            continue;
+        }
+        out.push(i);
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// "မြန်မာစာ" (Myanmar script): မြ | န် | မာ | စာ.
+    const MYANMAR: &str = "\u{1019}\u{103C}\u{1014}\u{103A}\u{1019}\u{102C}\u{1005}\u{102C}";
+
+    fn split<'a>(s: &'a str, at: &[usize]) -> Vec<&'a str> {
+        let mut v = Vec::new();
+        for (n, &a) in at.iter().enumerate() {
+            let b = at.get(n + 1).copied().unwrap_or(s.len());
+            v.push(&s[a..b]);
+        }
+        v
+    }
+
+    #[test]
+    fn myanmar_vowel_signs_stay_in_their_syllable() {
+        // Graphemes alone would cut "မာ" before the aa sign U+102C.
+        assert_eq!(split(MYANMAR, &cluster_starts(MYANMAR)), vec!["မြ", "န်", "မာ", "စာ"]);
+        // The prevowel ေ (U+1031) follows its consonant in memory: one cluster, as is visarga း.
+        assert_eq!(split("ကြေး", &cluster_starts("ကြေး")), vec!["ကြေး"]);
+        // Stacked consonants (virama U+1039) and kinzi join the syllable they hang from.
+        let stacked = "\u{1019}\u{1039}\u{1018}\u{102C}"; // မ္ဘာ
+        assert_eq!(cluster_starts(stacked), vec![0]);
+        let kinzi = "\u{1021}\u{1004}\u{103A}\u{1039}\u{1002}\u{101C}\u{102D}\u{1015}\u{103A}"; // အင်္ဂလိပ်
+        assert_eq!(split(kinzi, &cluster_starts(kinzi)), vec!["အ", "င်္ဂ", "လိ", "ပ်"]);
+    }
+
+    #[test]
+    fn khmer_subscripts_and_indic_conjuncts_are_one_cluster() {
+        // ខ្មែរ: ខ + coeng + ម + ែ, then រ.
+        assert_eq!(split("ខ្មែរ", &cluster_starts("ខ្មែរ")), vec!["ខ្មែ", "រ"]);
+        // Devanagari conjuncts are grapheme clusters already.
+        assert_eq!(split("क्षि हि", &cluster_starts("क्षि हि")), vec!["क्षि", " ", "हि"]);
+        // Latin is untouched: one cluster per letter, combining accents included.
+        assert_eq!(split("e\u{301}a", &cluster_starts("e\u{301}a")), vec!["e\u{301}", "a"]);
+    }
+
+    #[test]
+    fn caret_steps_skip_over_whole_clusters() {
+        let s = MYANMAR;
+        assert_eq!(next_cluster(s, 0), 6);
+        assert_eq!(next_cluster(s, 12), 18, "past the aa sign, not before it");
+        assert_eq!(prev_cluster(s, 18), 12);
+        assert_eq!(prev_cluster(s, 0), 0);
+        assert_eq!(next_cluster(s, s.len()), s.len());
+        assert!(!is_cluster_boundary(s, 15) && is_cluster_boundary(s, 12));
+        // Hostile offsets: past the end, inside a character.
+        assert_eq!(next_cluster(s, 1_000), s.len());
+        assert!(!is_cluster_boundary(s, 1));
+        assert_eq!(next_cluster(s, 1), 6);
+        assert_eq!(prev_cluster(s, 13), 6);
+        assert_eq!(prev_cluster("", 5), 0);
+        assert_eq!(next_cluster("", 0), 0);
+    }
+
+    #[test]
+    fn myanmar_wraps_between_syllables() {
+        // မြန်မာစာ: not before န (န် is a final, killed by the asat), so before မာ and စာ.
+        assert_eq!(myanmar_breaks(MYANMAR), vec![12, 18]);
+        // Never before a stacked consonant or one followed by medial + asat.
+        assert!(myanmar_breaks("\u{1019}\u{1039}\u{1018}\u{102C}").is_empty());
+        assert!(myanmar_breaks("ကျွန်").is_empty(), "န် is the final of ကျွန်");
+        // Not between Latin and Myanmar (UAX #14 handles that) or inside Latin.
+        assert!(myanmar_breaks("abcက").is_empty());
+        assert!(myanmar_breaks("").is_empty());
+    }
+
+    #[test]
+    fn backspace_by_character_in_brahmic_scripts_only() {
+        assert!(backspaces_by_char('ေ') && backspaces_by_char('ि') && backspaces_by_char('្'));
+        assert!(!backspaces_by_char('\u{301}') && !backspaces_by_char('a') && !backspaces_by_char('語'));
+    }
+}
diff --git a/crates/doc/src/connector.rs b/crates/doc/src/connector.rs
new file mode 100644
index 0000000000..5f662a24f5
--- /dev/null
+++ b/crates/doc/src/connector.rs
@@ -0,0 +1,263 @@
+//! Connectors and the shape properties beyond fill and outline: a shape's drawing id, its text
+//! warp, and a connector's ends.
+//!
+//! A connector (DrawingML `straightConnector1`, `bentConnector3`, `curvedConnector3`) is a line
+//! from its frame's top-left to its bottom-right corner (flips swap the corners). Each end may be
+//! glued to a connection site of another shape (`a:stCxn` / `a:endCxn`, ECMA-376 §20.1.2.2.36 and
+//! §20.1.2.2.13: the shape's drawing id and a site index). When a glued shape moves, [`route`]
+//! gives the connector's new frame from its ends.
+
+use serde::{Deserialize, Serialize};
+
+use crate::graphic::PathSeg;
+use crate::para::{GroupChild, InlineObject, ShapeKind};
+use crate::wordart::TextWarp;
+
+/// The rest of a shape's properties. Empty (the default) for most shapes.
+#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct ShapeExtra {
+    /// The drawing id connectors refer to (`wp:docPr/@id`, `wps:cNvPr/@id`); 0 = none. Kept only
+    /// for shapes a connector is glued to.
+    #[serde(skip_serializing_if = "is_zero")]
+    pub id: u32,
+    /// The text's warp (Text Effects › Transform).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub warp: Option<TextWarp>,
+    /// What a connector's start and end are glued to.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub start: Option<ConnEnd>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub end: Option<ConnEnd>,
+    /// Arrowheads at a line's or connector's start (`a:headEnd`) and end (`a:tailEnd`).
+    #[serde(skip_serializing_if = "is_false")]
+    pub arrow_start: bool,
+    #[serde(skip_serializing_if = "is_false")]
+    pub arrow_end: bool,
+}
+
+fn is_zero(v: &u32) -> bool {
+    *v == 0
+}
+fn is_false(v: &bool) -> bool {
+    !*v
+}
+
+impl ShapeExtra {
+    pub fn is_empty(&self) -> bool {
+        *self == ShapeExtra::default()
+    }
+}
+
+/// One glued end of a connector: the drawing id of the shape and its connection site index.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ConnEnd {
+    pub id: u32,
+    pub site: u32,
+}
+
+/// Largest connection site index read from a file.
+pub const MAX_SITE: u32 = 64;
+
+impl ShapeKind {
+    /// A connector (straight, elbow or curved): a line that can be glued to shapes.
+    pub fn is_connector(self) -> bool {
+        matches!(self, ShapeKind::StraightConnector | ShapeKind::ElbowConnector | ShapeKind::CurvedConnector)
+    }
+    /// A line or connector: drawn as an open path, never filled.
+    pub fn is_open(self) -> bool {
+        self == ShapeKind::Line || self.is_connector()
+    }
+}
+
+/// The connection sites of a `kind` shape `w` × `h`, in its own unrotated frame, by index. The
+/// order follows the preset shapes' connection lists (for a rectangle: top, left, bottom, right).
+pub fn sites(kind: ShapeKind, w: f32, h: f32) -> Vec<(f32, f32)> {
+    let (w, h) = (wordcraft_geom::finite(w), wordcraft_geom::finite(h));
+    let (cx, cy) = (w / 2.0, h / 2.0);
+    match kind {
+        ShapeKind::Ellipse => {
+            // The four sides, and the points of the ellipse at 45° between them.
+            let (dx, dy) = (cx * std::f32::consts::FRAC_1_SQRT_2, cy * std::f32::consts::FRAC_1_SQRT_2);
+            vec![(cx, 0.0), (cx - dx, cy - dy), (0.0, cy), (cx - dx, cy + dy), (cx, h), (cx + dx, cy + dy), (w, cy), (cx + dx, cy - dy)]
+        }
+        ShapeKind::Triangle => vec![(cx, 0.0), (cx / 2.0, cy), (0.0, h), (cx, h), (w, h), (cx + cx / 2.0, cy)],
+        ShapeKind::Line | ShapeKind::StraightConnector | ShapeKind::ElbowConnector | ShapeKind::CurvedConnector => vec![(0.0, 0.0), (w, h)],
+        _ => vec![(cx, 0.0), (0.0, cy), (cx, h), (w, cy)],
+    }
+}
+
+/// Site `site` of a `kind` shape with frame `rect` (x, y, w, h) on the page, turned and flipped by
+/// `spin` about its centre. `None` for a site the shape doesn't have.
+pub fn site_point(kind: ShapeKind, rect: [f32; 4], spin: wordcraft_geom::Spin, site: u32) -> Option<(f32, f32)> {
+    let [x, y, w, h] = rect;
+    let (sx, sy) = *sites(kind, w, h).get(site as usize)?;
+    let (cx, cy) = (x + w / 2.0, y + h / 2.0);
+    let (px, py) = spin.apply(cx, cy, x + sx, y + sy);
+    (px.is_finite() && py.is_finite()).then_some((px, py))
+}
+
+/// The site of a `kind` shape (frame `rect`, `spin`) nearest to page point `at`: its index, point
+/// and distance.
+pub fn nearest_site(kind: ShapeKind, rect: [f32; 4], spin: wordcraft_geom::Spin, at: (f32, f32)) -> Option<(u32, (f32, f32), f32)> {
+    let n = sites(kind, rect[2], rect[3]).len() as u32;
+    (0..n)
+        .filter_map(|i| site_point(kind, rect, spin, i).map(|p| (i, p, ((p.0 - at.0).powi(2) + (p.1 - at.1).powi(2)).sqrt())))
+        .min_by(|a, b| a.2.total_cmp(&b.2))
+}
+
+/// A connector's frame: top-left corner, size and flips.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Frame {
+    pub x: f32,
+    pub y: f32,
+    pub w: f32,
+    pub h: f32,
+    pub flip_h: bool,
+    pub flip_v: bool,
+}
+
+/// The frame of a connector from `start` to `end`.
+pub fn route(start: (f32, f32), end: (f32, f32)) -> Frame {
+    let f = wordcraft_geom::finite;
+    let (x0, y0, x1, y1) = (f(start.0), f(start.1), f(end.0), f(end.1));
+    Frame { x: x0.min(x1), y: y0.min(y1), w: (x1 - x0).abs(), h: (y1 - y0).abs(), flip_h: x1 < x0, flip_v: y1 < y0 }
+}
+
+/// A connector's start and end from its frame (the inverse of [`route`]).
+pub fn ends(x: f32, y: f32, w: f32, h: f32, flip_h: bool, flip_v: bool) -> ((f32, f32), (f32, f32)) {
+    let (xa, xb) = if flip_h { (x + w, x) } else { (x, x + w) };
+    let (ya, yb) = if flip_v { (y + h, y) } else { (y, y + h) };
+    ((xa, ya), (xb, yb))
+}
+
+/// The path of a connector `kind` in a `w` × `h` frame at the origin, from its top-left to its
+/// bottom-right corner (flips are the frame's turn): straight, an elbow through the middle (out
+/// horizontally, across, in horizontally), or an S-curve. `None` for other kinds.
+pub fn connector_segs(kind: ShapeKind, w: f32, h: f32) -> Option<Vec<PathSeg>> {
+    let (w, h) = (wordcraft_geom::finite(w), wordcraft_geom::finite(h));
+    let mx = w / 2.0;
+    Some(match kind {
+        ShapeKind::StraightConnector => vec![PathSeg::Move(0.0, 0.0), PathSeg::Line(w, h)],
+        ShapeKind::ElbowConnector => vec![PathSeg::Move(0.0, 0.0), PathSeg::Line(mx, 0.0), PathSeg::Line(mx, h), PathSeg::Line(w, h)],
+        ShapeKind::CurvedConnector => vec![PathSeg::Move(0.0, 0.0), PathSeg::Cubic(mx, 0.0, mx, h, w, h)],
+        _ => return None,
+    })
+}
+
+/// The direction (unit vector) a line or connector `kind` arrives at its end (`at_end`) or
+/// leaves its start, in its unflipped `w` × `h` frame: where an arrowhead points.
+pub fn end_direction(kind: ShapeKind, w: f32, h: f32, at_end: bool) -> (f32, f32) {
+    let (dx, dy) = match kind {
+        ShapeKind::ElbowConnector | ShapeKind::CurvedConnector => {
+            if w.abs() > 0.01 || h.abs() < 0.01 {
+                (1.0, 0.0)
+            } else {
+                (0.0, 1.0)
+            }
+        }
+        ShapeKind::Line => (w, -h),
+        _ => (w, h),
+    };
+    let len = (dx * dx + dy * dy).sqrt();
+    let (ux, uy) = if len > 1e-6 && len.is_finite() { (dx / len, dy / len) } else { (1.0, 0.0) };
+    if at_end { (ux, uy) } else { (-ux, -uy) }
+}
+
+/// Re-route the glued connectors among a group's members (they share the group's coordinate
+/// space). Returns whether any moved.
+pub fn reroute_group(children: &mut [GroupChild]) -> bool {
+    let shapes: Vec<(u32, ShapeKind, [f32; 4], wordcraft_geom::Spin)> = children
+        .iter()
+        .filter_map(|c| match &c.obj {
+            InlineObject::Shape { kind, w, h, float, extra, .. } if extra.id != 0 => Some((extra.id, *kind, [c.x, c.y, *w, *h], float.spin())),
+            _ => None,
+        })
+        .collect();
+    if shapes.is_empty() {
+        return false;
+    }
+    let find = |e: Option<ConnEnd>| {
+        let e = e?;
+        let (_, kind, rect, spin) = shapes.iter().find(|s| s.0 == e.id)?;
+        site_point(*kind, *rect, *spin, e.site)
+    };
+    let mut moved = false;
+    for c in children.iter_mut() {
+        let InlineObject::Shape { kind, w, h, float, extra, .. } = &mut c.obj else { continue };
+        if !kind.is_connector() || (extra.start.is_none() && extra.end.is_none()) {
+            continue;
+        }
+        let (s0, e0) = ends(c.x, c.y, *w, *h, float.flip_h, float.flip_v);
+        let (s, e) = (find(extra.start).unwrap_or(s0), find(extra.end).unwrap_or(e0));
+        let f = route(s, e);
+        let same = (f.x - c.x).abs() < 0.01 && (f.y - c.y).abs() < 0.01 && (f.w - *w).abs() < 0.01 && (f.h - *h).abs() < 0.01;
+        if same && f.flip_h == float.flip_h && f.flip_v == float.flip_v && float.rot == 0.0 {
+            continue;
+        }
+        c.x = f.x;
+        c.y = f.y;
+        *w = f.w;
+        *h = f.h;
+        float.rot = 0.0;
+        float.flip_h = f.flip_h;
+        float.flip_v = f.flip_v;
+        moved = true;
+    }
+    moved
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::para::Float;
+
+    fn shape(kind: ShapeKind, w: f32, h: f32, extra: ShapeExtra) -> InlineObject {
+        InlineObject::Shape {
+            kind,
+            w,
+            h,
+            fill: None,
+            stroke: None,
+            stroke_width: 1.0,
+            float: Float::default(),
+            story: None,
+            freeform: None,
+            effects: Default::default(),
+            extra,
+        }
+    }
+
+    #[test]
+    fn route_and_ends_are_inverse() {
+        for (s, e) in [((0.0, 0.0), (10.0, 5.0)), ((10.0, 5.0), (0.0, 0.0)), ((3.0, 9.0), (7.0, 1.0))] {
+            let f = route(s, e);
+            assert_eq!(ends(f.x, f.y, f.w, f.h, f.flip_h, f.flip_v), (s, e));
+        }
+    }
+
+    #[test]
+    fn group_connectors_follow_their_shapes() {
+        let a = ShapeExtra { id: 7, ..Default::default() };
+        let b = ShapeExtra { id: 9, ..Default::default() };
+        let link = ShapeExtra { start: Some(ConnEnd { id: 7, site: 3 }), end: Some(ConnEnd { id: 9, site: 2 }), ..Default::default() };
+        let mut kids = vec![
+            GroupChild { x: 0.0, y: 0.0, obj: shape(ShapeKind::Rectangle, 20.0, 10.0, a) },
+            GroupChild { x: 100.0, y: 50.0, obj: shape(ShapeKind::Ellipse, 20.0, 10.0, b) },
+            GroupChild { x: 0.0, y: 0.0, obj: shape(ShapeKind::ElbowConnector, 1.0, 1.0, link) },
+        ];
+        assert!(reroute_group(&mut kids));
+        // From the rectangle's right side (20, 5) to the ellipse's left side (100, 55).
+        let c = &kids[2];
+        let InlineObject::Shape { w, h, float, .. } = &c.obj else { panic!() };
+        assert_eq!((c.x, c.y, *w, *h, float.flip_h, float.flip_v), (20.0, 5.0, 80.0, 50.0, false, false));
+        assert!(!reroute_group(&mut kids), "settled");
+        // A connection to a missing id or site keeps that end where it was.
+        if let InlineObject::Shape { extra, .. } = &mut kids[2].obj {
+            extra.end = Some(ConnEnd { id: 404, site: 0 });
+            extra.start = Some(ConnEnd { id: 7, site: 99 });
+        }
+        assert!(!reroute_group(&mut kids));
+    }
+}
diff --git a/crates/doc/src/control.rs b/crates/doc/src/control.rs
new file mode 100644
index 0000000000..c4d8b9581a
--- /dev/null
+++ b/crates/doc/src/control.rs
@@ -0,0 +1,720 @@
+//! Content controls (`w:sdt`, ECMA-376 §17.5.2): fields of a form or template — rich and plain
+//! text, check boxes, combo boxes and drop-down lists, date pickers, pictures, building block
+//! galleries and repeating sections.
+//!
+//! A control around text is a [`InlineObject::ControlStart`] … [`InlineObject::ControlEnd`]
+//! marker pair in the paragraph text, like a range field: its content is the ordinary content
+//! between the markers, possibly spanning paragraphs (a block-level control sits around whole
+//! paragraphs: its start at the start of the first, its end at the end of the last). Pairs nest
+//! like brackets and never cross a block list. A control whose content starts or ends with a
+//! table, and controls around table rows or cells, are kept on the table, row or cell
+//! ([`ControlWrap`]) for the round trip.
+//!
+//! Editing can leave a marker without its partner. Deletions keep a marker whose partner is
+//! outside what's deleted (so deleting across a control's edge empties it rather than breaking
+//! it); writers call [`Document::balance_controls`] so a saved file always has whole controls.
+
+use serde::{Deserialize, Serialize};
+
+use crate::para::OBJ;
+use crate::{Block, Blocks, Document, InlineObject, Path, Pos, StoryRef};
+
+/// Deepest table nesting scanned (matches `walk` in the crate root).
+const MAX_DEPTH: usize = 16;
+/// Longest tag, title or list text kept from a file.
+pub const MAX_CONTROL_TEXT: usize = 1024;
+/// Most list entries a combo box or drop-down list keeps.
+pub const MAX_LIST_ITEMS: usize = 1000;
+
+/// What may be done to a control (`w:lock`).
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub enum ControlLock {
+    #[default]
+    Unlocked,
+    /// The control can't be deleted; its content can be edited.
+    SdtLocked,
+    /// The content can't be edited; the control can be deleted.
+    ContentLocked,
+    /// Neither.
+    SdtContentLocked,
+}
+
+impl ControlLock {
+    pub fn from_ooxml(v: &str) -> ControlLock {
+        match v {
+            "sdtLocked" => ControlLock::SdtLocked,
+            "contentLocked" => ControlLock::ContentLocked,
+            "sdtContentLocked" => ControlLock::SdtContentLocked,
+            _ => ControlLock::Unlocked,
+        }
+    }
+    /// The `w:lock` value, `None` when unlocked.
+    pub fn ooxml(self) -> Option<&'static str> {
+        match self {
+            ControlLock::Unlocked => None,
+            ControlLock::SdtLocked => Some("sdtLocked"),
+            ControlLock::ContentLocked => Some("contentLocked"),
+            ControlLock::SdtContentLocked => Some("sdtContentLocked"),
+        }
+    }
+    pub fn from_flags(no_delete: bool, no_edit: bool) -> ControlLock {
+        match (no_delete, no_edit) {
+            (false, false) => ControlLock::Unlocked,
+            (true, false) => ControlLock::SdtLocked,
+            (false, true) => ControlLock::ContentLocked,
+            (true, true) => ControlLock::SdtContentLocked,
+        }
+    }
+    /// The control itself can be deleted.
+    pub fn can_delete(self) -> bool {
+        matches!(self, ControlLock::Unlocked | ControlLock::ContentLocked)
+    }
+    /// Its content can be edited.
+    pub fn can_edit(self) -> bool {
+        matches!(self, ControlLock::Unlocked | ControlLock::SdtLocked)
+    }
+}
+
+/// An entry of a combo box or drop-down list.
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
+pub struct ListItem {
+    /// What the control shows.
+    pub display: String,
+    /// What it stores (`w:value`); the display text when empty.
+    pub value: String,
+}
+
+impl ListItem {
+    pub fn value(&self) -> &str {
+        if self.value.is_empty() { &self.display } else { &self.value }
+    }
+}
+
+/// The kind of a content control and its settings.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
+#[serde(tag = "type", rename_all = "camelCase")]
+pub enum ControlKind {
+    /// Formatted text, paragraphs, anything (also controls of a type we don't model, whose type
+    /// element is kept in [`ContentControl::extra`]).
+    #[default]
+    RichText,
+    /// Unformatted text (`w:text`), on one line unless `multi_line`.
+    #[serde(rename_all = "camelCase")]
+    Text {
+        #[serde(default)]
+        multi_line: bool,
+    },
+    /// A check box (`w14:checkbox`): the content is the state's symbol.
+    #[serde(rename_all = "camelCase")]
+    CheckBox { checked: bool, checked_char: char, checked_font: String, unchecked_char: char, unchecked_font: String },
+    /// A list to choose from, or type into (`w:comboBox`).
+    #[serde(rename_all = "camelCase")]
+    ComboBox {
+        items: Vec<ListItem>,
+        #[serde(default)]
+        last_value: String,
+    },
+    /// A list to choose from (`w:dropDownList`).
+    #[serde(rename_all = "camelCase")]
+    DropDown {
+        items: Vec<ListItem>,
+        #[serde(default)]
+        last_value: String,
+    },
+    /// A date (`w:date`): `full_date` is ISO 8601, `format` a date picture (`M/d/yyyy`).
+    #[serde(rename_all = "camelCase")]
+    Date {
+        #[serde(default)]
+        full_date: String,
+        #[serde(default)]
+        format: String,
+        #[serde(default)]
+        lid: String,
+        #[serde(default)]
+        calendar: String,
+        #[serde(default)]
+        store_as: String,
+    },
+    /// A picture (`w:picture`).
+    Picture,
+    /// A building block gallery (`w:docPartList`) or a building block placed from one
+    /// (`w:docPartObj`: tables of contents, cover pages, bibliographies).
+    #[serde(rename_all = "camelCase")]
+    Gallery {
+        /// `w:docPartList` rather than `w:docPartObj`.
+        #[serde(default)]
+        list: bool,
+        #[serde(default)]
+        gallery: String,
+        #[serde(default)]
+        category: String,
+        #[serde(default)]
+        unique: bool,
+    },
+    /// A repeating section (`w15:repeatingSection`), whose items are repeated.
+    #[serde(rename_all = "camelCase")]
+    RepeatingSection {
+        #[serde(default)]
+        title: String,
+        #[serde(default)]
+        no_insert_delete: bool,
+    },
+    /// One item of a repeating section (`w15:repeatingSectionItem`).
+    RepeatingSectionItem,
+}
+
+/// Default check box symbols: ballot box with X, ballot box.
+pub const CHECKED: char = '\u{2612}';
+pub const UNCHECKED: char = '\u{2610}';
+
+impl ControlKind {
+    pub fn check_box() -> ControlKind {
+        ControlKind::CheckBox {
+            checked: false,
+            checked_char: CHECKED,
+            checked_font: String::new(),
+            unchecked_char: UNCHECKED,
+            unchecked_font: String::new(),
+        }
+    }
+    /// The command-friendly name (`richText`, `checkBox`…).
+    pub fn name(&self) -> &'static str {
+        match self {
+            ControlKind::RichText => "richText",
+            ControlKind::Text { .. } => "plainText",
+            ControlKind::CheckBox { .. } => "checkBox",
+            ControlKind::ComboBox { .. } => "comboBox",
+            ControlKind::DropDown { .. } => "dropDown",
+            ControlKind::Date { .. } => "date",
+            ControlKind::Picture => "picture",
+            ControlKind::Gallery { .. } => "buildingBlock",
+            ControlKind::RepeatingSection { .. } => "repeatingSection",
+            ControlKind::RepeatingSectionItem => "repeatingSectionItem",
+        }
+    }
+    /// The list entries of a combo box or drop-down list.
+    pub fn items(&self) -> Option<&Vec<ListItem>> {
+        match self {
+            ControlKind::ComboBox { items, .. } | ControlKind::DropDown { items, .. } => Some(items),
+            _ => None,
+        }
+    }
+    /// Typed text may go in (not a check box, drop-down list or picture).
+    pub fn takes_typing(&self) -> bool {
+        !matches!(self, ControlKind::CheckBox { .. } | ControlKind::DropDown { .. } | ControlKind::Picture)
+    }
+    /// The text its placeholder shows by default.
+    pub fn default_placeholder(&self) -> &'static str {
+        match self {
+            ControlKind::ComboBox { .. } | ControlKind::DropDown { .. } => "Pick an option.",
+            ControlKind::Date { .. } => "Pick a date.",
+            ControlKind::CheckBox { .. } | ControlKind::Picture | ControlKind::RepeatingSection { .. } | ControlKind::RepeatingSectionItem => "",
+            _ => "Type here.",
+        }
+    }
+}
+
+/// A content control's properties (`w:sdtPr`).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
+pub struct ContentControl {
+    /// `w:id` (unique in the document).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub id: Option<i64>,
+    /// `w:tag`: a name for programs.
+    pub tag: String,
+    /// `w:alias`: the title shown on the control.
+    pub title: String,
+    pub lock: ControlLock,
+    /// The building block holding the placeholder text (`w:placeholder/w:docPart`).
+    pub placeholder: String,
+    /// The content is the placeholder text (`w:showingPlcHdr`).
+    pub showing_placeholder: bool,
+    /// The control goes away once its content is edited (`w:temporary`).
+    pub temporary: bool,
+    pub kind: ControlKind,
+    /// The text shown while the control is empty.
+    pub placeholder_text: String,
+    /// Around whole paragraphs rather than inside one.
+    pub block: bool,
+    /// The run properties of `w:sdtPr` (`w:rPr`), kept verbatim (XML).
+    #[serde(skip_serializing_if = "String::is_empty")]
+    pub rpr_xml: String,
+    /// Other `w:sdtPr` children we don't model, kept verbatim (XML) in file order.
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub extra: Vec<String>,
+    /// `w:sdtEndPr`, kept verbatim (XML).
+    #[serde(skip_serializing_if = "String::is_empty")]
+    pub end_pr_xml: String,
+}
+
+impl ContentControl {
+    pub fn new(kind: ControlKind) -> ContentControl {
+        let placeholder_text = kind.default_placeholder().to_string();
+        ContentControl { kind, placeholder_text, ..Default::default() }
+    }
+    /// The text to show while empty.
+    pub fn placeholder_shown(&self) -> &str {
+        if self.placeholder_text.is_empty() { self.kind.default_placeholder() } else { &self.placeholder_text }
+    }
+}
+
+/// Content controls around a table, row or cell (see the module docs): the controls that open
+/// just before it, outermost first, and how many of the open ones close just after it.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
+pub struct ControlWrap {
+    pub open: Vec<ContentControl>,
+    pub close: u32,
+}
+
+impl ControlWrap {
+    pub fn is_empty(&self) -> bool {
+        self.open.is_empty() && self.close == 0
+    }
+}
+
+/// A control boundary in a block list (not looking into table cells).
+#[derive(Clone, Debug, PartialEq)]
+pub enum ControlEvent<'a> {
+    /// A control opens: at a `ControlStart` at byte `off` of paragraph `block`, or (`off`
+    /// `None`) before table `block`.
+    Open { block: usize, off: Option<usize>, control: &'a ContentControl },
+    /// The innermost open control closes: at a `ControlEnd` at `off`, or after table `block`.
+    Close { block: usize, off: Option<usize> },
+}
+
+impl ControlEvent<'_> {
+    pub fn block(&self) -> usize {
+        match self {
+            ControlEvent::Open { block, .. } | ControlEvent::Close { block, .. } => *block,
+        }
+    }
+    pub fn off(&self) -> Option<usize> {
+        match self {
+            ControlEvent::Open { off, .. } | ControlEvent::Close { off, .. } => *off,
+        }
+    }
+}
+
+/// The control boundaries of a block list, in order.
+pub fn control_events(bl: &Blocks) -> Vec<ControlEvent<'_>> {
+    let mut out = Vec::new();
+    for (i, b) in bl.iter().enumerate() {
+        match &**b {
+            Block::Para(p) => {
+                if !p.objects.iter().any(|o| matches!(o, InlineObject::ControlStart { .. } | InlineObject::ControlEnd)) {
+                    continue;
+                }
+                for off in p.object_offsets() {
+                    match p.object_at(off) {
+                        Some(InlineObject::ControlStart { control }) => out.push(ControlEvent::Open { block: i, off: Some(off), control }),
+                        Some(InlineObject::ControlEnd) => out.push(ControlEvent::Close { block: i, off: Some(off) }),
+                        _ => {}
+                    }
+                }
+            }
+            Block::Table(t) => {
+                for c in &t.controls.open {
+                    out.push(ControlEvent::Open { block: i, off: None, control: c });
+                }
+                for _ in 0..t.controls.close.min(10_000) {
+                    out.push(ControlEvent::Close { block: i, off: None });
+                }
+            }
+        }
+    }
+    out
+}
+
+/// Pair events like brackets: `(open index, close index, depth)` for each whole control (in the
+/// order they close), and the indexes of events without a partner.
+pub fn pair_events(events: &[ControlEvent]) -> (Vec<(usize, usize, usize)>, Vec<usize>) {
+    let mut open: Vec<usize> = Vec::new();
+    let (mut pairs, mut orphans) = (Vec::new(), Vec::new());
+    for (i, e) in events.iter().enumerate() {
+        match e {
+            ControlEvent::Open { .. } => open.push(i),
+            ControlEvent::Close { .. } => match open.pop() {
+                Some(o) => pairs.push((o, i, open.len())),
+                None => orphans.push(i),
+            },
+        }
+    }
+    orphans.extend(open);
+    orphans.sort_unstable();
+    (pairs, orphans)
+}
+
+/// A whole content control around paragraph content.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ControlRange {
+    pub control: ContentControl,
+    /// Where the `ControlStart` marker is.
+    pub start: Pos,
+    /// Where the `ControlEnd` marker is (the content is everything between the two).
+    pub end: Pos,
+    /// Number of enclosing controls in the same block list.
+    pub depth: usize,
+}
+
+impl ControlRange {
+    /// The start of the content (just after the start marker).
+    pub fn content_start(&self) -> Pos {
+        Pos { off: self.start.off + OBJ.len_utf8(), ..self.start.clone() }
+    }
+    /// Whether `p` is inside the control (between its markers, either edge included).
+    pub fn contains(&self, p: &Pos) -> bool {
+        p.story == self.start.story
+            && (&p.path, p.off) >= (&self.start.path, self.start.off + OBJ.len_utf8())
+            && (&p.path, p.off) <= (&self.end.path, self.end.off)
+    }
+    /// Whether the content is empty (nothing but other controls' markers would be content too).
+    pub fn is_empty(&self) -> bool {
+        self.start.path == self.end.path && self.end.off == self.start.off + OBJ.len_utf8()
+    }
+}
+
+fn scan(story: StoryRef, bl: &Blocks, prefix: &mut Vec<u32>, depth: usize, out: &mut Vec<ControlRange>) {
+    if depth > MAX_DEPTH {
+        return;
+    }
+    let events = control_events(bl);
+    if !events.is_empty() {
+        let (pairs, _) = pair_events(&events);
+        for (o, c, d) in pairs {
+            let (Some(ControlEvent::Open { block: ob, off: Some(oo), control }), Some(ControlEvent::Close { block: cb, off: Some(co) })) =
+                (events.get(o), events.get(c))
+            else {
+                continue;
+            };
+            let at = |b: usize, off: usize| {
+                let mut path = prefix.clone();
+                path.push(u32::try_from(b).unwrap_or(u32::MAX));
+                Pos::new(story, Path(path), off)
+            };
+            out.push(ControlRange { control: (*control).clone(), start: at(*ob, *oo), end: at(*cb, *co), depth: d });
+        }
+    }
+    for (i, b) in bl.iter().enumerate() {
+        if let Block::Table(t) = &**b {
+            prefix.push(u32::try_from(i).unwrap_or(u32::MAX));
+            for (r, row) in t.rows.iter().enumerate() {
+                for (c, cell) in row.cells.iter().enumerate() {
+                    prefix.push(u32::try_from(r).unwrap_or(u32::MAX));
+                    prefix.push(u32::try_from(c).unwrap_or(u32::MAX));
+                    scan(story, &cell.blocks, prefix, depth + 1, out);
+                    prefix.pop();
+                    prefix.pop();
+                }
+            }
+            prefix.pop();
+        }
+    }
+}
+
+/// Positions of the markers without a partner in a block list and the cells inside it.
+fn orphans(bl: &Blocks, prefix: &mut Vec<u32>, depth: usize, out: &mut Vec<(Path, usize)>, tables: &mut Vec<(Path, usize, bool)>) {
+    if depth > MAX_DEPTH {
+        return;
+    }
+    let events = control_events(bl);
+    let (_, lone) = pair_events(&events);
+    for k in lone {
+        let Some(e) = events.get(k) else { continue };
+        let mut path = prefix.clone();
+        path.push(u32::try_from(e.block()).unwrap_or(u32::MAX));
+        match (e, e.off()) {
+            (_, Some(off)) => out.push((Path(path), off)),
+            (ControlEvent::Open { .. }, None) => {
+                // Which of the table's opens: count those before it on the same table.
+                let nth = events.iter().take(k).filter(|x| matches!(x, ControlEvent::Open { block, off: None, .. } if *block == e.block())).count();
+                tables.push((Path(path), nth, true));
+            }
+            (ControlEvent::Close { .. }, None) => tables.push((Path(path), 0, false)),
+        }
+    }
+    for (i, b) in bl.iter().enumerate() {
+        if let Block::Table(t) = &**b {
+            prefix.push(u32::try_from(i).unwrap_or(u32::MAX));
+            for (r, row) in t.rows.iter().enumerate() {
+                for (c, cell) in row.cells.iter().enumerate() {
+                    prefix.push(u32::try_from(r).unwrap_or(u32::MAX));
+                    prefix.push(u32::try_from(c).unwrap_or(u32::MAX));
+                    orphans(&cell.blocks, prefix, depth + 1, out, tables);
+                    prefix.pop();
+                    prefix.pop();
+                }
+            }
+            prefix.pop();
+        }
+    }
+}
+
+/// Remove the markers without a partner from a list of blocks (a copied fragment).
+pub fn balance_blocks(blocks: &mut [Block]) {
+    let mut bl: Blocks = blocks.iter().cloned().map(std::sync::Arc::new).collect();
+    if balance_list(&mut bl) > 0 {
+        for (dst, src) in blocks.iter_mut().zip(bl) {
+            *dst = std::sync::Arc::try_unwrap(src).unwrap_or_else(|a| (*a).clone());
+        }
+    }
+}
+
+/// Remove orphan markers (and table wraps) from a block list; returns how many went.
+fn balance_list(bl: &mut Blocks) -> usize {
+    let (mut paras, mut tables) = (Vec::new(), Vec::new());
+    orphans(bl, &mut Vec::new(), 0, &mut paras, &mut tables);
+    if paras.is_empty() && tables.is_empty() {
+        return 0;
+    }
+    let mut d = Document { body: std::mem::take(bl), ..Document::new() };
+    let removed = d.remove_orphans(StoryRef::Body, paras, tables);
+    *bl = d.body;
+    removed
+}
+
+impl Document {
+    fn control_stories(&self) -> Vec<StoryRef> {
+        std::iter::once(StoryRef::Body).chain(self.parts.keys().map(|k| StoryRef::Part(*k))).collect()
+    }
+
+    /// The whole content controls of a story (around paragraph content), in the order they close.
+    pub fn control_ranges(&self, story: StoryRef) -> Vec<ControlRange> {
+        let mut out = Vec::new();
+        if let Some(bl) = self.story(story) {
+            scan(story, bl, &mut Vec::new(), 0, &mut out);
+        }
+        out
+    }
+
+    /// The innermost content control holding `p`.
+    pub fn control_at(&self, p: &Pos) -> Option<ControlRange> {
+        let para = self.para_at(p)?;
+        // Cheap test first: no controls anywhere near.
+        if !para.objects.iter().any(|o| matches!(o, InlineObject::ControlStart { .. } | InlineObject::ControlEnd))
+            && !self.story_has_controls(p.story)
+        {
+            return None;
+        }
+        self.control_ranges(p.story)
+            .into_iter()
+            .filter(|r| r.contains(p))
+            .max_by(|a, b| (&a.start.path, a.start.off).cmp(&(&b.start.path, b.start.off)))
+    }
+
+    fn story_has_controls(&self, s: StoryRef) -> bool {
+        let Some(bl) = self.story(s) else { return false };
+        let mut any = false;
+        for b in bl {
+            crate::edit::each_para(b, 0, &mut |p| any |= p.objects.iter().any(|o| matches!(o, InlineObject::ControlStart { .. })));
+            if any {
+                return true;
+            }
+        }
+        false
+    }
+
+    /// The control whose start marker is at `start`, to change.
+    pub fn control_mut(&mut self, start: &Pos) -> Option<&mut ContentControl> {
+        let p = self.para_mut(start.story, &start.path).ok()?;
+        p.touch();
+        match p.object_at_mut(start.off)? {
+            InlineObject::ControlStart { control } => Some(control),
+            _ => None,
+        }
+    }
+
+    /// The content of a control as plain text (paragraphs joined by `\n`).
+    pub fn control_text(&self, r: &ControlRange) -> String {
+        let a = r.content_start();
+        let mut out = String::new();
+        for path in self.paths_between(&a, &r.end) {
+            let Some(p) = self.para(a.story, &path) else { continue };
+            let from = if path == a.path { a.off } else { 0 };
+            let to = if path == r.end.path { r.end.off } else { p.len() };
+            if !out.is_empty() {
+                out.push('\n');
+            }
+            let mut k = p.text.get(..from).map(|t| t.chars().filter(|c| *c == OBJ).count()).unwrap_or(0);
+            for c in p.text.get(from..to.max(from)).unwrap_or("").chars() {
+                if c == OBJ {
+                    if let Some(o) = p.objects.get(k) {
+                        out.push_str(o.plain_text());
+                    }
+                    k += 1;
+                } else {
+                    out.push(c);
+                }
+            }
+        }
+        out
+    }
+
+    /// Whether any story holds a control marker without its partner.
+    pub fn has_unbalanced_controls(&self) -> bool {
+        self.control_stories().into_iter().any(|s| {
+            self.story(s).is_some_and(|bl| {
+                let (mut p, mut t) = (Vec::new(), Vec::new());
+                orphans(bl, &mut Vec::new(), 0, &mut p, &mut t);
+                !p.is_empty() || !t.is_empty()
+            })
+        })
+    }
+
+    /// Remove control markers (and table wraps' opens and closes) that have no partner. Returns
+    /// how many were removed. (Row and cell wraps are balanced as they are written.)
+    pub fn balance_controls(&mut self) -> usize {
+        let mut removed = 0;
+        for s in self.control_stories() {
+            let Some(bl) = self.story(s) else { continue };
+            let (mut paras, mut tables) = (Vec::new(), Vec::new());
+            orphans(bl, &mut Vec::new(), 0, &mut paras, &mut tables);
+            removed += self.remove_orphans(s, paras, tables);
+        }
+        removed
+    }
+
+    fn remove_orphans(&mut self, s: StoryRef, mut paras: Vec<(Path, usize)>, tables: Vec<(Path, usize, bool)>) -> usize {
+        let mut removed = 0;
+        // Last first, so earlier offsets in the same paragraph stay valid.
+        paras.sort();
+        for (path, off) in paras.into_iter().rev() {
+            if let Ok(p) = self.para_mut(s, &path)
+                && p.delete(off, off + OBJ.len_utf8()).is_ok()
+            {
+                removed += 1;
+            }
+        }
+        // Table opens: highest index first per table.
+        let mut tables = tables;
+        tables.sort_by(|a, b| a.0.cmp(&b.0).then(b.1.cmp(&a.1)));
+        for (path, nth, open) in tables {
+            if let Ok(t) = self.table_mut(s, &path) {
+                if open {
+                    if nth < t.controls.open.len() {
+                        t.controls.open.remove(nth);
+                        removed += 1;
+                    }
+                } else if t.controls.close > 0 {
+                    t.controls.close -= 1;
+                    removed += 1;
+                }
+            }
+        }
+        removed
+    }
+
+    /// The control markers in `a..b` whose partner is outside it (a deletion keeps them).
+    pub(crate) fn kept_control_markers(&self, a: &Pos, b: &Pos) -> Vec<(Path, usize)> {
+        let mut out = Vec::new();
+        let paths = self.paths_between(a, b);
+        let any = paths.iter().any(|p| {
+            self.para(a.story, p).is_some_and(|q| q.objects.iter().any(|o| matches!(o, InlineObject::ControlStart { .. } | InlineObject::ControlEnd)))
+        });
+        if !any {
+            return out;
+        }
+        let inside = |p: &Path, off: usize| (p, off) >= (&a.path, a.off) && (p, off + OBJ.len_utf8()) <= (&b.path, b.off);
+        // Ranges whose markers are in paragraphs.
+        let ranges = self.control_ranges(a.story);
+        for r in &ranges {
+            let (s, e) = (inside(&r.start.path, r.start.off), inside(&r.end.path, r.end.off));
+            if s && !e {
+                out.push((r.start.path.clone(), r.start.off));
+            }
+            if e && !s {
+                out.push((r.end.path.clone(), r.end.off));
+            }
+        }
+        // Markers paired with a table wrap: their partner is never deleted with them.
+        for path in &paths {
+            let Some(p) = self.para(a.story, path) else { continue };
+            for off in p.object_offsets() {
+                if !inside(path, off) || !matches!(p.object_at(off), Some(InlineObject::ControlStart { .. } | InlineObject::ControlEnd)) {
+                    continue;
+                }
+                let paired = ranges.iter().any(|r| (r.start.path == *path && r.start.off == off) || (r.end.path == *path && r.end.off == off));
+                if !paired && self.paired_with_table(a.story, path, off) {
+                    out.push((path.clone(), off));
+                }
+            }
+        }
+        out.sort();
+        out.dedup();
+        out
+    }
+
+    /// Whether the marker at `path`/`off` is paired with a table wrap's open or close.
+    fn paired_with_table(&self, s: StoryRef, path: &Path, off: usize) -> bool {
+        let Some(bl) = self.container(s, path) else { return false };
+        let events = control_events(bl);
+        let (pairs, _) = pair_events(&events);
+        let me = events.iter().position(|e| e.block() == path.last() && e.off() == Some(off));
+        let Some(me) = me else { return false };
+        pairs.iter().any(|(o, c, _)| {
+            (*o == me && events.get(*c).is_some_and(|e| e.off().is_none())) || (*c == me && events.get(*o).is_some_and(|e| e.off().is_none()))
+        })
+    }
+
+    /// Where typing at `p` should go: a caret at the start of a paragraph, before the start of
+    /// a block-level control, goes inside it; one at the end, after a block-level control's
+    /// end, goes inside it too (the control is around the whole paragraph).
+    pub fn typing_pos(&self, p: &Pos) -> Pos {
+        let Some(para) = self.para_at(p) else { return p.clone() };
+        let is_start = |off: usize| matches!(para.object_at(off), Some(InlineObject::ControlStart { control }) if control.block);
+        let is_end = |off: usize| matches!(para.object_at(off), Some(InlineObject::ControlEnd));
+        let w = OBJ.len_utf8();
+        let mut off = p.off;
+        // Only block starts before the caret (or none) and block starts right after it.
+        let before_ok = (0..off).step_by(w).all(&is_start) && off.is_multiple_of(w);
+        if before_ok && is_start(off) {
+            while is_start(off) {
+                off += w;
+            }
+            return Pos { off, ..p.clone() };
+        }
+        if p.off == para.len() && off >= w && is_end(off - w) {
+            // Step back over the trailing ends that close block-level controls.
+            let ranges = self.control_ranges(p.story);
+            while off >= w && is_end(off - w) && ranges.iter().any(|r| r.end.path == p.path && r.end.off == off - w && r.control.block) {
+                off -= w;
+            }
+            return Pos { off, ..p.clone() };
+        }
+        p.clone()
+    }
+}
+
+/// Every control in `bl` (and its tables), for walks that need them all.
+pub fn walk_controls(bl: &Blocks, f: &mut dyn FnMut(&ContentControl)) {
+    fn go(bl: &Blocks, f: &mut dyn FnMut(&ContentControl), depth: usize) {
+        if depth > MAX_DEPTH {
+            return;
+        }
+        for b in bl {
+            match &**b {
+                Block::Para(p) => {
+                    for o in &p.objects {
+                        if let InlineObject::ControlStart { control } = o {
+                            f(control);
+                        }
+                    }
+                }
+                Block::Table(t) => {
+                    t.controls.open.iter().for_each(&mut *f);
+                    for r in &t.rows {
+                        r.controls.open.iter().for_each(&mut *f);
+                        for c in &r.cells {
+                            c.controls.open.iter().for_each(&mut *f);
+                            go(&c.blocks, f, depth + 1);
+                        }
+                    }
+                }
+            }
+        }
+    }
+    go(bl, f, 0);
+}
diff --git a/crates/doc/src/edit.rs b/crates/doc/src/edit.rs
index cc379698c5..12de09d5d0 100644
--- a/crates/doc/src/edit.rs
+++ b/crates/doc/src/edit.rs
@@ -60,7 +60,7 @@ pub(crate) fn each_para<'a>(b: &'a Block, depth: usize, f: &mut dyn FnMut(&'a Pa
     }
 }
 
-fn each_para_mut(b: &mut Block, depth: usize, f: &mut dyn FnMut(&mut Paragraph)) {
+pub(crate) fn each_para_mut(b: &mut Block, depth: usize, f: &mut dyn FnMut(&mut Paragraph)) {
     match b {
         Block::Para(p) => f(p),
         Block::Table(t) if depth < 16 => {
@@ -299,21 +299,40 @@ impl Document {
         if a.story != b.story {
             return Err(DocError::Invalid("range spans stories".into()));
         }
+        // Content control markers whose partner is outside the range stay (the control is
+        // emptied, not broken).
+        let kept = self.kept_control_markers(&a, &b);
+        let kept_in = |path: &Path| -> Vec<usize> { kept.iter().filter(|(p, _)| p == path).map(|(_, o)| *o).collect() };
         if a.path == b.path {
-            self.para_mut(a.story, &a.path)?.delete(a.off, b.off)?;
+            self.para_mut(a.story, &a.path)?.delete_except(a.off, b.off, &kept_in(&a.path))?;
             return Ok(a);
         }
         if a.path.parent() == b.path.parent() {
             // Same container: trim the ends, drop the blocks between, join.
             let (ia, ib) = (a.path.last(), b.path.last());
+            // Kept markers of the paragraphs in between move to the join.
+            let mut moved: Vec<(InlineObject, CharProps)> = Vec::new();
+            for (path, off) in &kept {
+                if *path != a.path
+                    && *path != b.path
+                    && let Some(p) = self.para(a.story, path)
+                    && let Some(o) = p.object_at(*off)
+                {
+                    moved.push((o.clone(), p.props_of_char(*off).clone()));
+                }
+            }
             {
                 let pa = self.para_mut(a.story, &a.path)?;
                 let end = pa.len();
-                pa.delete(a.off, end)?;
+                pa.delete_except(a.off, end, &kept_in(&a.path))?;
+                for (o, props) in moved {
+                    let at = pa.len();
+                    pa.insert_object(at, o, &props)?;
+                }
             }
             let mut tail = {
                 let pb = self.para_mut(b.story, &b.path)?;
-                pb.delete(0, b.off)?;
+                pb.delete_except(0, b.off, &kept_in(&b.path))?;
                 pb.clone()
             };
             let bl = self.container_mut(a.story, &a.path)?;
@@ -337,7 +356,7 @@ impl Document {
                 let to = if *p == b.path { b.off } else { para.len() };
                 (from, to)
             };
-            self.para_mut(a.story, p)?.delete(from, to)?;
+            self.para_mut(a.story, p)?.delete_except(from, to, &kept_in(p))?;
         }
         // Drop top-level tables strictly between a and b at a's level.
         if a.path.depth() == 0 && b.path.depth() > 0 {
@@ -378,9 +397,21 @@ impl Document {
         Ok(())
     }
 
-    /// Apply `f` to the paragraph properties of every paragraph touched by `a..b`.
+    /// The paragraphs paragraph formatting of `a..b` applies to: [`Self::paths_between`] without
+    /// the last paragraph when a non-empty range ends at its start (Select Paragraph ends there
+    /// to include the paragraph mark). A caret applies to its own paragraph (Word, #418).
+    pub fn para_paths_in(&self, a: &Pos, b: &Pos) -> Vec<Path> {
+        let (a, b) = order(a, b);
+        let mut paths = self.paths_between(&a, &b);
+        if b.off == 0 && a.path != b.path && paths.len() > 1 && paths.last() == Some(&b.path) {
+            paths.pop();
+        }
+        paths
+    }
+
+    /// Apply `f` to the paragraph properties of every paragraph `a..b` covers ([`Self::para_paths_in`]).
     pub fn format_paragraphs(&mut self, a: &Pos, b: &Pos, f: &dyn Fn(&mut ParaProps)) -> Result<()> {
-        for p in self.paths_between(a, b) {
+        for p in self.para_paths_in(a, b) {
             let para = self.para_mut(a.story, &p)?;
             f(&mut para.props);
             para.touch();
@@ -390,7 +421,9 @@ impl Document {
 
     /// Copy `a..b` into a fragment (with copies of the text boxes in it).
     pub fn copy_range(&self, a: &Pos, b: &Pos) -> Fragment {
-        let blocks = self.copy_blocks(a, b);
+        let mut blocks = self.copy_blocks(a, b);
+        // Half a content control (one marker without the other) isn't copied.
+        crate::control::balance_blocks(&mut blocks);
         let parts = self.text_box_parts(&blocks);
         Fragment { blocks, parts }
     }
@@ -667,6 +700,7 @@ mod tests {
             story,
             freeform: None,
             effects: Default::default(),
+            extra: Default::default(),
         }
     }
 
diff --git a/crates/doc/src/freeform.rs b/crates/doc/src/freeform.rs
index 06d80c0bcb..6b46d3b0f4 100644
--- a/crates/doc/src/freeform.rs
+++ b/crates/doc/src/freeform.rs
@@ -88,18 +88,22 @@ pub struct Freeform {
     /// by the eraser.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub ink: Option<InkTool>,
+    /// Ink: its place in the order the strokes were drawn (1, 2, 3…), for Draw › Ink Replay.
+    /// `None` for ink from files that don't record it (replayed first, in document order).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub order: Option<u32>,
 }
 
 impl Default for Freeform {
     fn default() -> Self {
-        Freeform { w: 0.0, h: 0.0, paths: Vec::new(), alpha: 1.0, ink: None }
+        Freeform { w: 0.0, h: 0.0, paths: Vec::new(), alpha: 1.0, ink: None, order: None }
     }
 }
 
 impl Freeform {
     /// An ink stroke through `pts` (shape-local points, already in the `w` × `h` frame).
     pub fn ink(tool: InkTool, w: f32, h: f32, pts: Vec<[f32; 2]>) -> Freeform {
-        Freeform { w, h, paths: vec![FreePath { pts, closed: false }], alpha: tool.alpha(), ink: Some(tool) }.sanitized()
+        Freeform { w, h, paths: vec![FreePath { pts, closed: false }], alpha: tool.alpha(), ink: Some(tool), order: None }.sanitized()
     }
 
     /// The same geometry with non-finite points dropped, coordinates clamped, the counts capped
@@ -183,7 +187,7 @@ mod tests {
     fn hostile_geometry_is_sanitized() {
         let mut pts = vec![[f32::NAN, 1.0], [2.0, f32::INFINITY], [1.0, 2.0], [1e30, -1e30]];
         pts.extend(std::iter::repeat_n([3.0, 3.0], MAX_POINTS * 2));
-        let f = Freeform { w: f32::NAN, h: -4.0, paths: vec![FreePath { pts, closed: false }], alpha: 7.0, ink: None }.sanitized();
+        let f = Freeform { w: f32::NAN, h: -4.0, paths: vec![FreePath { pts, closed: false }], alpha: 7.0, ink: None, order: None }.sanitized();
         assert_eq!((f.w, f.h, f.alpha), (0.0, 0.0, 1.0));
         let p = &f.paths[0].pts;
         assert_eq!(p.len(), MAX_POINTS);
diff --git a/crates/doc/src/graphic.rs b/crates/doc/src/graphic.rs
index c07229700c..091a0b426c 100644
--- a/crates/doc/src/graphic.rs
+++ b/crates/doc/src/graphic.rs
@@ -1,11 +1,14 @@
-//! Charts and SmartArt diagrams: drawings shown but not edited, kept as neutral items ready to draw.
+//! Charts and SmartArt diagrams: drawings kept as neutral items ready to draw. Charts and SmartArt
+//! WordCraft can edit also keep their model ([`crate::chart::ChartSpec`],
+//! [`crate::smart_art::SmartArtSpec`]); the rest are shown, not edited.
 
 use serde::{Deserialize, Serialize};
 
 use crate::para::ShapeKind;
 use crate::props::Rgb;
 
-/// A drawing shown but not edited: a chart or a SmartArt diagram, as items ready to draw.
+/// A chart or a SmartArt diagram, as items ready to draw (and, for an editable chart or SmartArt
+/// graphic, its model).
 #[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Graphic {
@@ -23,6 +26,15 @@ pub struct Graphic {
     /// only these items). `None` for graphics made some other way.
     #[serde(skip)]
     pub source: Option<std::sync::Arc<Embedded>>,
+    /// A SmartArt graphic WordCraft can edit (one it made, or one read back exactly as it wrote
+    /// it): saving writes the diagram parts from it, and the items are drawn from it. See
+    /// [`crate::smart_art`].
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub smart_art: Option<std::sync::Arc<crate::smart_art::SmartArtSpec>>,
+    /// A chart WordCraft can edit (one it made, or one read back that holds nothing more): saving
+    /// writes the chart part from it, and the items are drawn from it. See [`crate::chart`].
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub chart: Option<std::sync::Arc<crate::chart::ChartSpec>>,
 }
 
 /// What an object read from a file needs to be written back as it was: its own markup in the
diff --git a/crates/doc/src/lib.rs b/crates/doc/src/lib.rs
index 40ad558c20..a0f2440060 100644
--- a/crates/doc/src/lib.rs
+++ b/crates/doc/src/lib.rs
@@ -11,6 +11,11 @@
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
 pub mod bidi;
+pub mod chart;
+mod cjk_numbers;
+pub mod cluster;
+pub mod connector;
+pub mod control;
 pub mod edit;
 pub mod effects;
 pub mod encoding;
@@ -18,6 +23,7 @@ pub mod eq;
 pub mod fields;
 pub mod freeform;
 pub mod graphic;
+pub mod link;
 pub mod math;
 pub mod math_edit;
 pub mod math_latex;
@@ -28,8 +34,10 @@ pub mod para;
 pub mod props;
 pub mod resolve;
 pub mod section;
+pub mod smart_art;
 pub mod styles;
 pub mod table;
+pub mod wordart;
 pub mod wrap;
 
 use std::collections::BTreeMap;
@@ -37,6 +45,7 @@ use std::sync::Arc;
 
 use serde::{Deserialize, Serialize};
 
+pub use control::{ContentControl, ControlKind, ControlLock, ControlRange, ControlWrap};
 pub use fields::FieldRange;
 pub use numbering::{ListKind, Numbering};
 pub use para::{InlineObject, Paragraph, Run};
@@ -331,7 +340,7 @@ impl Document {
 pub struct Source {
     /// Unique tag cited by CITATION fields.
     pub tag: String,
-    /// book, article, website, report, film, other
+    /// book, bookSection, article (journal), periodical, conference, report, website, film, other
     pub kind: String,
     /// "Last, First; Last, First"
     pub author: String,
@@ -343,6 +352,15 @@ pub struct Source {
     pub volume: String,
     pub pages: String,
     pub url: String,
+    /// More bibliography fields (Create Source › Show All Bibliography Fields).
+    pub editor: String,
+    pub edition: String,
+    pub issue: String,
+    pub month: String,
+    pub day: String,
+    /// Date accessed (websites).
+    pub accessed: String,
+    pub doi: String,
 }
 
 /// A custom document property (File › Info › Properties › Custom). Citation managers keep
@@ -382,6 +400,13 @@ pub struct Settings {
     pub even_odd_headers: bool,
     pub mirror_margins: bool,
     pub auto_hyphenation: bool,
+    /// Hyphenation zone (`w:hyphenationZone`), points: a line is hyphenated only when breaking
+    /// it at a word boundary would leave more than this empty at its end.
+    pub hyphenation_zone: f32,
+    /// Words in capitals may be hyphenated (`w:doNotHyphenateCaps` turns it off).
+    pub hyphenate_caps: bool,
+    /// Most consecutive lines that may end with a hyphen (`w:consecutiveHyphenLimit`); 0 = no limit.
+    pub consecutive_hyphen_limit: u32,
     pub page_color: Option<Rgb>,
     pub watermark: Option<Watermark>,
     /// Theme fonts (major = headings, minor = body).
@@ -398,7 +423,18 @@ pub struct Settings {
     pub footnote_pr: section::NoteProps,
     #[serde(skip_serializing_if = "section::NoteProps::is_empty")]
     pub endnote_pr: section::NoteProps,
+    /// Restrict Editing, when enforced: `readOnly`, `comments`, `trackedChanges`, `forms`, or
+    /// `none` when only formatting is restricted (`w:documentProtection w:edit`).
     pub protection: Option<String>,
+    /// Restrict Editing limits formatting to the styles that aren't locked, and forbids direct
+    /// formatting (`w:formatting="1"`).
+    #[serde(skip_serializing_if = "std::ops::Not::not")]
+    pub protect_formatting: bool,
+    /// The protection password's hash, as the file's `w:documentProtection` attributes
+    /// (`w:algorithmName`, `w:hashValue`, `w:saltValue`, `w:spinCount`, or the older
+    /// `w:cryptAlgorithmSid`, `w:hash`, `w:salt`…). Empty: no password.
+    #[serde(skip_serializing_if = "Vec::is_empty")]
+    pub protect_hash: Vec<(String, String)>,
     /// Word compatibility mode the document is laid out in (`compatibilityMode`): 15 for Word
     /// 2013 and later, which places a table's border at the margin rather than its text and lets
     /// justified lines shrink their spaces to fit more text.
@@ -409,6 +445,16 @@ pub struct Settings {
     /// Equation options (`m:mathPr`), when the document has them.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub math: Option<math::MathProps>,
+    /// Citation and bibliography style (References › Style) by name, when the document
+    /// records one (OOXML's `b:Sources/@StyleName`).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub bib_style: Option<String>,
+    /// The template the document is attached to (Tools › Templates and Add-ins): the target of
+    /// `w:attachedTemplate`'s relationship, a path or `file:` URL as the file gives it.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub attached_template: Option<String>,
+    /// Update the document's styles from the attached template when it is opened (`w:linkStyles`).
+    pub link_styles: bool,
 }
 
 /// Word's compatibility mode for documents that don't state one.
@@ -417,6 +463,9 @@ pub const LEGACY_COMPAT_MODE: u32 = 12;
 /// The compatibility mode of documents created by Word 2013 and later, and by WordCraft.
 pub const COMPAT_MODE_CURRENT: u32 = 15;
 
+/// Word's hyphenation zone when a document doesn't set one (0.25"), points.
+pub const DEFAULT_HYPHENATION_ZONE: f32 = 18.0;
+
 /// ECMA-376 §17.15.1.44/45: 180 twentieths of a point when a document doesn't say.
 pub const DEFAULT_GRID: f32 = 9.0;
 
@@ -460,6 +509,9 @@ impl Default for Settings {
             even_odd_headers: false,
             mirror_margins: false,
             auto_hyphenation: false,
+            hyphenation_zone: DEFAULT_HYPHENATION_ZONE,
+            hyphenate_caps: true,
+            consecutive_hyphen_limit: 0,
             page_color: None,
             watermark: None,
             major_font: styles::HEADING_FONT.into(),
@@ -471,10 +523,15 @@ impl Default for Settings {
             footnote_pr: section::NoteProps::default(),
             endnote_pr: section::NoteProps::default(),
             protection: None,
+            protect_formatting: false,
+            protect_hash: Vec::new(),
             compat_mode: COMPAT_MODE_CURRENT,
             grid_h: DEFAULT_GRID,
             grid_v: DEFAULT_GRID,
             math: None,
+            bib_style: None,
+            attached_template: None,
+            link_styles: false,
         }
     }
 }
@@ -1004,6 +1061,49 @@ impl Document {
         out
     }
 
+    /// A drawing id no shape uses yet (for gluing a connector to a shape that has none).
+    pub fn next_shape_id(&self) -> u32 {
+        let mut max = 0u32;
+        let mut see = |o: &InlineObject| match o {
+            InlineObject::Shape { extra, .. } => max = max.max(extra.id),
+            InlineObject::Group { children, .. } => {
+                for c in children {
+                    if let InlineObject::Shape { extra, .. } = &c.obj {
+                        max = max.max(extra.id);
+                    }
+                }
+            }
+            _ => {}
+        };
+        for blocks in std::iter::once(&self.body).chain(self.parts.values().map(|p| &p.blocks)) {
+            for b in blocks {
+                edit::each_para(b, 0, &mut |p| p.objects.iter().for_each(&mut see));
+            }
+        }
+        max.saturating_add(1).max(1)
+    }
+
+    /// Change every inline object in every story (paragraphs inside tables too), copying only
+    /// the blocks whose paragraphs `wants` says have objects to change.
+    pub fn objects_mut(&mut self, wants: &dyn Fn(&InlineObject) -> bool, f: &mut dyn FnMut(&mut InlineObject)) {
+        let mut stories: Vec<&mut Blocks> = vec![&mut self.body];
+        stories.extend(self.parts.values_mut().map(|p| &mut p.blocks));
+        for blocks in stories {
+            for b in blocks.iter_mut() {
+                let mut any = false;
+                edit::each_para(b, 0, &mut |p| any |= p.objects.iter().any(wants));
+                if any {
+                    edit::each_para_mut(Arc::make_mut(b), 0, &mut |p| {
+                        if p.objects.iter().any(wants) {
+                            p.objects.iter_mut().filter(|o| wants(o)).for_each(&mut *f);
+                            p.touch();
+                        }
+                    });
+                }
+            }
+        }
+    }
+
     /// Number of paragraphs in the body (all depths).
     pub fn paragraph_count(&self) -> usize {
         self.para_paths(StoryRef::Body).len()
@@ -1048,6 +1148,47 @@ impl Document {
         self.custom_props.len() != n
     }
 
+    /// Ranges that stay editable while the document is protected (Restrict Editing exceptions),
+    /// in document order across every story: the [`InlineObject::PermStart`]'s id, group and
+    /// editor, its start (just after the marker) and its end (at the matching
+    /// [`InlineObject::PermEnd`], or the end of the story when it has none).
+    pub fn perm_ranges(&self) -> Vec<PermRange> {
+        let mut out: Vec<PermRange> = Vec::new();
+        let stories = std::iter::once(StoryRef::Body).chain(self.parts.keys().map(|k| StoryRef::Part(*k)));
+        for story in stories {
+            let mut open: Vec<usize> = Vec::new();
+            for path in self.para_paths(story) {
+                let Some(p) = self.para(story, &path) else { continue };
+                for off in p.object_offsets() {
+                    match p.object_at(off) {
+                        Some(InlineObject::PermStart { id, group, editor }) => {
+                            let start = Pos { story, path: path.clone(), off: off + para::OBJ.len_utf8() };
+                            open.push(out.len());
+                            out.push(PermRange { id: *id, group: group.clone(), editor: editor.clone(), start: start.clone(), end: start });
+                        }
+                        Some(InlineObject::PermEnd { id }) => {
+                            if let Some(k) = open.iter().rposition(|i| out.get(*i).is_some_and(|r| r.id == *id)) {
+                                let i = open.remove(k);
+                                if let Some(r) = out.get_mut(i) {
+                                    r.end = Pos { story, path: path.clone(), off };
+                                }
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
+            // A range left open runs to the end of its story.
+            let end = self.end_of(story);
+            for i in open {
+                if let Some(r) = out.get_mut(i) {
+                    r.end = end.clone();
+                }
+            }
+        }
+        out
+    }
+
     /// Bookmark names in the body, in order.
     pub fn bookmarks(&self) -> Vec<(String, Pos)> {
         let mut out = Vec::new();
@@ -1064,6 +1205,25 @@ impl Document {
     }
 }
 
+/// A range that stays editable while the document is protected; see [`Document::perm_ranges`].
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PermRange {
+    pub id: u32,
+    /// Editing group (`everyone`, `editors`…); empty when the range names an editor.
+    pub group: String,
+    /// The one editor the range is for; empty for a group.
+    pub editor: String,
+    pub start: Pos,
+    pub end: Pos,
+}
+
+impl PermRange {
+    /// Can everyone edit it (rather than one person or group)?
+    pub fn everyone(&self) -> bool {
+        self.group.eq_ignore_ascii_case("everyone")
+    }
+}
+
 /// Words in `s` (tokens separated by whitespace that contain at least one alphanumeric char).
 pub fn count_words(s: &str) -> usize {
     s.split(|c: char| c.is_whitespace() || c == para::OBJ).filter(|w| w.chars().any(char::is_alphanumeric)).count()
diff --git a/crates/doc/src/link.rs b/crates/doc/src/link.rs
new file mode 100644
index 0000000000..73e4f5ea86
--- /dev/null
+++ b/crates/doc/src/link.rs
@@ -0,0 +1,81 @@
+//! Which hyperlink targets may leave the document: followed by the OS, or written into an
+//! exported HTML/Markdown file where a browser would run them.
+
+/// Whether Ctrl/⌘+click may hand a document's hyperlink to the system: web and email links only,
+/// so a document can't launch `file:` paths, programs or custom-scheme handlers. Exact: a leading
+/// space or a control character makes it not a link.
+pub fn is_web_or_mail_link(url: &str) -> bool {
+    let Some((scheme, _)) = url.split_once(':') else { return false };
+    ["http", "https", "mailto"].iter().any(|s| scheme.eq_ignore_ascii_case(s))
+}
+
+/// Whether a hyperlink may be written as an `href` (or Markdown destination) in an exported file:
+/// a web or email link, a bookmark (`#name`) or a relative path. Scripts (`javascript:`,
+/// `vbscript:`), `data:`, `file:` and every other scheme are refused, read the way a browser reads
+/// a URL: ASCII control characters and spaces are dropped first, so `java\nscript:` is a script.
+pub fn is_safe_href(url: &str) -> bool {
+    match scheme(url) {
+        Some(s) => matches!(s.as_str(), "http" | "https" | "mailto"),
+        None => !url.trim().is_empty(),
+    }
+}
+
+/// The scheme a browser would see in `url` (RFC 3986 §3.1: a letter, then letters, digits, `+`,
+/// `-` or `.`, up to the first `:`), lower-cased; `None` for a relative reference.
+fn scheme(url: &str) -> Option<String> {
+    let cleaned: String = url.chars().filter(|c| !c.is_ascii_control() && *c != ' ').collect();
+    let (s, _) = cleaned.split_once(':')?;
+    let mut chars = s.chars();
+    let first = chars.next()?;
+    (first.is_ascii_alphabetic() && chars.all(|c| c.is_ascii_alphanumeric() || matches!(c, '+' | '-' | '.'))).then(|| s.to_ascii_lowercase())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn only_web_and_mail_links_are_followable() {
+        for ok in ["https://example.com/a?b#c", "http://example.com", "HTTPS://EXAMPLE.COM", "mailto:someone@example.com"] {
+            assert!(is_web_or_mail_link(ok), "{ok}");
+        }
+        for bad in [
+            "file:///etc/passwd",
+            "C:\\Windows\\System32\\calc.exe",
+            "/usr/bin/xterm",
+            "javascript:alert(1)",
+            "ms-msdt:/id",
+            " https://example.com",
+            "https\u{0}://example.com",
+            "",
+            "example.com",
+            "#top",
+        ] {
+            assert!(!is_web_or_mail_link(bad), "{bad:?}");
+        }
+    }
+
+    /// An exported `href` may be a web/mail link, a bookmark or a relative path: never a script
+    /// or another scheme, however a browser would normalise it.
+    #[test]
+    fn exported_hrefs_allow_bookmarks_and_relative_paths_but_no_scripts() {
+        for ok in ["https://example.com/x", "mailto:a@b.c", "#top", "other.html", "docs/guide.html#s2", "../up.html", "?q=1"] {
+            assert!(is_safe_href(ok), "{ok}");
+        }
+        for bad in [
+            "javascript:alert(1)",
+            "JavaScript:alert(1)",
+            "java\nscript:alert(1)",
+            "\tjavascript:alert(1)",
+            " javascript:alert(1)",
+            "java\u{0}script:alert(1)",
+            "vbscript:MsgBox(1)",
+            "data:text/html,<script>alert(1)</script>",
+            "file:///etc/passwd",
+            "ms-msdt:/id",
+            "",
+        ] {
+            assert!(!is_safe_href(bad), "{bad:?}");
+        }
+    }
+}
diff --git a/crates/doc/src/numbering.rs b/crates/doc/src/numbering.rs
index 5b61a8249e..655937da37 100644
--- a/crates/doc/src/numbering.rs
+++ b/crates/doc/src/numbering.rs
@@ -300,7 +300,13 @@ impl Counters {
                 let k = (d as usize).saturating_sub(1).min(8);
                 let val = vals.get(k).copied().unwrap_or(0);
                 let val = if val == 0 { level_def(k).map(|l| l.start).unwrap_or(1) } else { val };
-                let fmt = if def.legal && k != lv { NumFormat::Decimal } else { level_def(k).map(|l| l.format).unwrap_or(NumFormat::Decimal) };
+                // Legal numbering (w:isLgl) shows every level in Arabic digits, whatever its own
+                // format (二 of a Chinese outline becomes 2 in "2.1").
+                let fmt = match level_def(k).map(|l| l.format).unwrap_or(NumFormat::Decimal) {
+                    NumFormat::DecimalZero => NumFormat::DecimalZero,
+                    _ if def.legal => NumFormat::Decimal,
+                    f => f,
+                };
                 label.push_str(&fmt.format(val));
             } else {
                 label.push(c);
@@ -371,6 +377,32 @@ mod tests {
         assert!(c.next_label(&n, 999, 0).is_none());
     }
 
+    #[test]
+    fn east_asian_labels_and_legal_numbering() {
+        // A Chinese outline: 第一章, then "一、" items, and a legal level showing 1.1.
+        let mut n = Numbering::default();
+        let id = n.add_list(ListKind::Numbered);
+        if let Some(a) = n.abstracts.first_mut() {
+            a.levels[0] = Level { format: NumFormat::ChineseCounting, text: "第%1章".into(), ..Level::default() };
+            a.levels[1] = Level { format: NumFormat::ChineseCounting, text: "%2、".into(), ..Level::default() };
+            a.levels[2] = Level { format: NumFormat::ChineseCounting, text: "%1.%2.%3".into(), legal: true, ..Level::default() };
+            a.levels[3] = Level { format: NumFormat::ChineseCounting, text: "（%4）".into(), ..Level::default() };
+        }
+        let mut c = Counters::default();
+        let mut l = |lv| c.next_label(&n, id, lv).unwrap().0;
+        assert_eq!(l(0), "第一章");
+        assert_eq!(l(1), "一、");
+        assert_eq!(l(1), "二、");
+        assert_eq!(l(1), "三、");
+        assert_eq!(l(2), "1.3.1", "legal numbering is decimal on every level");
+        assert_eq!(l(3), "（一）");
+        for _ in 0..9 {
+            l(3);
+        }
+        assert_eq!(l(3), "（十一）");
+        assert_eq!(l(0), "第二章");
+    }
+
     #[test]
     fn legal_labels() {
         let mut n = Numbering::default();
diff --git a/crates/doc/src/para.rs b/crates/doc/src/para.rs
index 9fd05d432f..8fec420714 100644
--- a/crates/doc/src/para.rs
+++ b/crates/doc/src/para.rs
@@ -208,6 +208,41 @@ pub struct Float {
     /// (unrotated) frame; `None` = derived from the object (see [`crate::wrap`]).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub wrap_polygon: Option<std::sync::Arc<crate::wrap::WrapPolygon>>,
+    /// What the drawing is, for screen readers and exports (`wp:docPr` `@descr`, `@title` and the
+    /// decorative mark). See [`InlineObject::alt_text`].
+    #[serde(skip_serializing_if = "AltText::is_empty")]
+    pub alt: AltText,
+}
+
+/// Longest alternative text kept (characters): hostile files and commands are capped.
+pub const MAX_ALT_TEXT: usize = 10_000;
+
+/// A drawing's alternative text (Picture/Shape Format › Accessibility › Alt Text).
+#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize, Default)]
+#[serde(default, rename_all = "camelCase")]
+pub struct AltText {
+    /// The description of a shape, text box or group. Pictures and charts keep theirs in their
+    /// own `alt`; read it with [`InlineObject::alt_text`], which knows where it is.
+    #[serde(skip_serializing_if = "String::is_empty")]
+    pub text: String,
+    /// The short title (`wp:docPr/@title`).
+    #[serde(skip_serializing_if = "String::is_empty")]
+    pub title: String,
+    /// Decorative: it adds nothing to the content, so screen readers skip it and the
+    /// accessibility checker doesn't ask for a description.
+    #[serde(skip_serializing_if = "is_false")]
+    pub decorative: bool,
+}
+
+impl AltText {
+    pub fn is_empty(&self) -> bool {
+        self.text.is_empty() && self.title.is_empty() && !self.decorative
+    }
+}
+
+/// `s` cut to [`MAX_ALT_TEXT`] characters.
+pub fn cap_alt(s: &str) -> String {
+    s.chars().take(MAX_ALT_TEXT).collect()
 }
 
 fn is_zero(v: &f32) -> bool {
@@ -259,6 +294,10 @@ pub enum ShapeKind {
     TextBox,
     /// A shape drawn point by point, such as ink (its geometry is the shape's `freeform`).
     Freeform,
+    /// Connectors: lines whose ends can be glued to other shapes (see [`crate::connector`]).
+    StraightConnector,
+    ElbowConnector,
+    CurvedConnector,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
@@ -369,6 +408,9 @@ pub enum InlineObject {
         /// Shadow, glow and soft edges.
         #[serde(default, skip_serializing_if = "crate::effects::ShapeEffects::is_empty")]
         effects: crate::effects::ShapeEffects,
+        /// Drawing id, text warp, connector ends and arrowheads.
+        #[serde(default, skip_serializing_if = "crate::connector::ShapeExtra::is_empty")]
+        extra: crate::connector::ShapeExtra,
     },
     /// Pictures, shapes and text boxes grouped into one object (Layout › Arrange › Group): it
     /// moves, wraps and resizes as one. Its members are laid out in the group's own coordinate
@@ -415,6 +457,13 @@ pub enum InlineObject {
     },
     /// The end of the innermost open [`InlineObject::FieldStart`].
     FieldEnd,
+    /// The start of a content control whose content is what follows, up to the matching
+    /// [`InlineObject::ControlEnd`]. See [`crate::control`].
+    ControlStart {
+        control: Box<crate::control::ContentControl>,
+    },
+    /// The end of the innermost open [`InlineObject::ControlStart`].
+    ControlEnd,
     NoteRef {
         kind: NoteKind,
         /// `Document::parts` id of the note's story.
@@ -435,6 +484,20 @@ pub enum InlineObject {
     CommentEnd {
         id: u32,
     },
+    /// The start of a range that stays editable while the document is protected (Restrict
+    /// Editing exceptions, `w:permStart`): for everyone (`group` = `everyone`), another editing
+    /// group, or one editor (`editor`, a user name or address).
+    PermStart {
+        id: u32,
+        #[serde(default, skip_serializing_if = "String::is_empty")]
+        group: String,
+        #[serde(default, skip_serializing_if = "String::is_empty")]
+        editor: String,
+    },
+    /// The end of the editable range [`InlineObject::PermStart`] with the same `id` opened.
+    PermEnd {
+        id: u32,
+    },
     /// An equation: its linear format (`x=(-b±√(b^2-4ac))/2a`, for plain text) and structure.
     /// A display equation sits on a line of its own.
     Equation {
@@ -603,10 +666,36 @@ impl InlineObject {
                 | InlineObject::BookmarkEnd { .. }
                 | InlineObject::CommentStart { .. }
                 | InlineObject::CommentEnd { .. }
+                | InlineObject::PermStart { .. }
+                | InlineObject::PermEnd { .. }
                 | InlineObject::FieldStart { .. }
                 | InlineObject::FieldEnd
+                | InlineObject::ControlStart { .. }
+                | InlineObject::ControlEnd
         )
     }
+    /// A drawing's description (alternative text), wherever it is kept.
+    pub fn alt_text(&self) -> &str {
+        match self {
+            InlineObject::Image { alt, .. } | InlineObject::Graphic { alt, .. } => alt,
+            InlineObject::Shape { float, .. } | InlineObject::Group { float, .. } => &float.alt.text,
+            _ => "",
+        }
+    }
+    /// Set a drawing's description (capped at [`MAX_ALT_TEXT`] characters); `false` if this is no drawing.
+    pub fn set_alt_text(&mut self, text: &str) -> bool {
+        let text = cap_alt(text);
+        match self {
+            InlineObject::Image { alt, .. } | InlineObject::Graphic { alt, .. } => *alt = text,
+            InlineObject::Shape { float, .. } | InlineObject::Group { float, .. } => float.alt.text = text,
+            _ => return false,
+        }
+        true
+    }
+    /// A drawing marked decorative.
+    pub fn is_decorative(&self) -> bool {
+        self.frame().is_some_and(|(_, _, f)| f.alt.decorative)
+    }
     pub fn is_floating(&self) -> bool {
         match self {
             InlineObject::Image { float, .. }
@@ -972,6 +1061,33 @@ impl Paragraph {
         Ok(())
     }
 
+    /// Delete `a..b` except the one-character objects at the offsets in `keep` (control
+    /// markers a deletion leaves in place).
+    pub fn delete_except(&mut self, a: usize, b: usize, keep: &[usize]) -> Result<()> {
+        let (a, b) = (a.min(b), a.max(b));
+        let mut keep: Vec<usize> =
+            keep.iter().copied().filter(|k| *k >= a && k + OBJ.len_utf8() <= b && self.text.get(*k..).is_some_and(|t| t.starts_with(OBJ))).collect();
+        if keep.is_empty() {
+            return self.delete(a, b);
+        }
+        keep.sort_unstable();
+        keep.dedup();
+        // Pieces between the kept objects, last first so earlier offsets stay valid.
+        let mut pieces = Vec::with_capacity(keep.len() + 1);
+        let mut from = a;
+        for k in &keep {
+            pieces.push((from, *k));
+            from = k + OBJ.len_utf8();
+        }
+        pieces.push((from, b));
+        for (x, y) in pieces.into_iter().rev() {
+            if y > x {
+                self.delete(x, y)?;
+            }
+        }
+        Ok(())
+    }
+
     /// Apply `f` to the formatting of `a..b`.
     pub fn format(&mut self, a: usize, b: usize, f: &dyn Fn(&mut CharProps)) -> Result<()> {
         let (a, b) = (a.min(b), a.max(b));
@@ -1060,19 +1176,24 @@ impl Paragraph {
         self.touch();
     }
 
-    /// Previous grapheme boundary before `off` (0 at start).
+    /// Previous caret stop before `off` (0 at start): a grapheme boundary that doesn't split a
+    /// complex-script syllable ([`crate::cluster`]).
     pub fn prev_boundary(&self, off: usize) -> usize {
-        use unicode_segmentation::GraphemeCursor;
-        let off = self.clamp(off);
-        let mut c = GraphemeCursor::new(off, self.text.len(), true);
-        c.prev_boundary(&self.text, 0).ok().flatten().unwrap_or(0)
+        crate::cluster::prev_cluster(&self.text, self.clamp(off))
     }
-    /// Next grapheme boundary after `off` (len at end).
+    /// Next caret stop after `off` (len at end), see [`Self::prev_boundary`].
     pub fn next_boundary(&self, off: usize) -> usize {
-        use unicode_segmentation::GraphemeCursor;
+        crate::cluster::next_cluster(&self.text, self.clamp(off))
+    }
+    /// Where Backspace at `off` deletes from: the previous character in the Brahmic scripts
+    /// (Myanmar, Khmer, Devanagari, Thai…), where it removes one vowel sign or stacked consonant
+    /// at a time, otherwise the previous caret stop.
+    pub fn backspace_from(&self, off: usize) -> usize {
         let off = self.clamp(off);
-        let mut c = GraphemeCursor::new(off, self.text.len(), true);
-        c.next_boundary(&self.text, 0).ok().flatten().unwrap_or(self.text.len())
+        match self.text.get(..off).and_then(|t| t.char_indices().next_back()) {
+            Some((i, c)) if crate::cluster::backspaces_by_char(c) => i,
+            _ => self.prev_boundary(off),
+        }
     }
     /// Start of the word at or before `off` (Ctrl+Left).
     pub fn word_start(&self, off: usize) -> usize {
diff --git a/crates/doc/src/props.rs b/crates/doc/src/props.rs
index c8cdcffb0e..4405d4d9b6 100644
--- a/crates/doc/src/props.rs
+++ b/crates/doc/src/props.rs
@@ -281,6 +281,10 @@ pub struct CharProps {
     pub emboss: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub engrave: Option<bool>,
+    /// WordArt text effects: fill, outline, shadow, glow, reflection ([MS-DOCX] `w14:` run
+    /// properties). Overlaid effect by effect.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub text_effects: Option<Box<crate::wordart::TextEffects>>,
     /// BCP 47 language tag (proofing).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub lang: Option<String>,
@@ -295,6 +299,10 @@ pub struct CharProps {
     /// Complex-script font (Arabic, Persian, Hebrew…; OOXML `w:rFonts/@w:cs`). `None` = `font`.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub font_cs: Option<String>,
+    /// East Asian font (Chinese, Japanese and Korean text; OOXML `w:rFonts/@w:eastAsia`). `None` =
+    /// inherit, then `font`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub font_ea: Option<String>,
     /// Complex-script size, points (`w:szCs`). `None` = the same as `size` (see [`CharProps::overlay`]).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub size_cs: Option<f32>,
@@ -390,7 +398,10 @@ impl CharProps {
     pub fn overlay(&mut self, patch: &CharProps) {
         overlay_fields!(self, patch; style, font, size, bold, italic, underline, underline_color, strike, double_strike, color, highlight,
             shading, border, vert_align, caps, small_caps, hidden, spacing, scale, position, kern, outline, shadow, emboss, engrave, lang, no_proof, rtl,
-            cs, font_cs, size_cs, bold_cs, italic_cs, lang_bidi, link, ins, del, fmt_change);
+            cs, font_cs, font_ea, size_cs, bold_cs, italic_cs, lang_bidi, link, ins, del, fmt_change);
+        if let Some(p) = &patch.text_effects {
+            self.text_effects.get_or_insert_with(Default::default).overlay(p);
+        }
         if patch.size.is_some() && patch.size_cs.is_none() {
             self.size_cs = None;
         }
@@ -644,6 +655,18 @@ pub struct ParaProps {
     /// First-line indent, points; negative = hanging.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub indent_first: Option<f32>,
+    /// Left (start) indent in characters (`w:leftChars` / `w:startChars`, stored by Word in
+    /// hundredths). A non-zero value wins over `indent_left`; one character is the size of the
+    /// paragraph mark's font. `Some(0.0)` cancels an inherited value. Common in East Asian documents.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub indent_left_chars: Option<f32>,
+    /// Right (end) indent in characters (`w:rightChars` / `w:endChars`), like `indent_left_chars`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub indent_right_chars: Option<f32>,
+    /// First-line indent in characters (`w:firstLineChars`; negative = `w:hangingChars`), like
+    /// `indent_left_chars`.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub indent_first_chars: Option<f32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub space_before: Option<f32>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -653,6 +676,10 @@ pub struct ParaProps {
     /// Ignore space before/after between paragraphs of the same style.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub contextual_spacing: Option<bool>,
+    /// `w:mirrorIndents` (ECMA-376 §17.3.1.18): the left and right indents are the inside and
+    /// outside ones, so they swap sides on even (left-hand) pages.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub mirror_indents: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub keep_next: Option<bool>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -716,8 +743,8 @@ pub struct ParaProps {
 
 impl ParaProps {
     pub fn overlay(&mut self, patch: &ParaProps) {
-        overlay_fields!(self, patch; style, align, indent_left, indent_right, indent_first, space_before, space_after, line_spacing,
-            contextual_spacing, keep_next, keep_lines, page_break_before, widow_control, outline_level, numbering, tabs, shading, borders,
+        overlay_fields!(self, patch; style, align, indent_left, indent_right, indent_first, indent_left_chars, indent_right_chars, indent_first_chars, space_before, space_after, line_spacing,
+            contextual_spacing, mirror_indents, keep_next, keep_lines, page_break_before, widow_control, outline_level, numbering, tabs, shading, borders,
             suppress_hyphens, suppress_line_numbers, bidi, drop_cap, kinsoku, word_wrap, overflow_punct, top_line_punct, auto_space_de, auto_space_dn,
             snap_to_grid);
     }
@@ -728,6 +755,15 @@ impl ParaProps {
     pub fn is_empty(&self) -> bool {
         *self == ParaProps::default()
     }
+    /// After setting indents in points: keep the indents in characters (left, right, first line)
+    /// an inherited style may set from winning over them, as Word does (`w:firstLineChars="0"`).
+    pub fn cancel_char_indents(&mut self, left: bool, right: bool, first: bool) {
+        for (on, chars) in [(left, &mut self.indent_left_chars), (right, &mut self.indent_right_chars), (first, &mut self.indent_first_chars)] {
+            if on {
+                *chars = Some(0.0);
+            }
+        }
+    }
     /// Just the formatting: without the tracked changes.
     pub fn formatting(&self) -> ParaProps {
         ParaProps { num_change: None, fmt_change: None, ..self.clone() }
@@ -873,8 +909,11 @@ pub struct TableProps {
     /// column, banded columns.
     pub look: TableLook,
     pub shading: Option<Rgb>,
-    /// Alternative text.
+    /// Alternative text: the title (`w:tblCaption`).
     pub caption: Option<String>,
+    /// Alternative text: the description (`w:tblDescription`).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub description: Option<String>,
     /// Floating placement (`w:tblpPr`); `None` for a table in the text flow.
     #[serde(skip_serializing_if = "Option::is_none")]
     pub float: Option<TableFloat>,
diff --git a/crates/doc/src/resolve.rs b/crates/doc/src/resolve.rs
index 1ec1c2187f..a96f35280a 100644
--- a/crates/doc/src/resolve.rs
+++ b/crates/doc/src/resolve.rs
@@ -36,6 +36,9 @@ pub struct ResolvedChar {
     pub shadow: bool,
     pub emboss: bool,
     pub engrave: bool,
+    /// WordArt text effects (sanitized; `None` when there are none).
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub text_effects: Option<Box<crate::wordart::TextEffects>>,
     pub link: Option<String>,
     pub ins: Option<u32>,
     pub del: Option<u32>,
@@ -49,6 +52,9 @@ pub struct ResolvedChar {
     pub cs: bool,
     /// Complex-script font, size, bold and italic (Arabic, Persian, Hebrew… text).
     pub font_cs: String,
+    /// East Asian font (Chinese, Japanese and Korean text), when one is set.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub font_ea: Option<String>,
     pub size_cs: f32,
     pub bold_cs: bool,
     pub italic_cs: bool,
@@ -80,6 +86,7 @@ impl ResolvedChar {
             shadow: c.shadow.unwrap_or(false),
             emboss: c.emboss.unwrap_or(false),
             engrave: c.engrave.unwrap_or(false),
+            text_effects: c.text_effects.as_deref().map(crate::wordart::TextEffects::sanitized).filter(|t| !t.is_empty()).map(Box::new),
             link: c.link.clone(),
             ins: c.ins,
             del: c.del,
@@ -89,6 +96,7 @@ impl ResolvedChar {
             rtl: c.rtl.unwrap_or(false),
             cs: c.cs.unwrap_or(false),
             font_cs: c.font_cs.clone().or_else(|| c.font.clone()).unwrap_or_else(|| crate::styles::BODY_FONT.to_string()),
+            font_ea: c.font_ea.clone(),
             size_cs: c.size_cs.or(c.size).unwrap_or(11.0).clamp(1.0, 1638.0),
             bold_cs: c.bold_cs.or(c.bold).unwrap_or(false),
             italic_cs: c.italic_cs.or(c.italic).unwrap_or(false),
@@ -132,6 +140,8 @@ pub struct ResolvedPara {
     pub space_after: f32,
     pub line_spacing: LineSpacing,
     pub contextual_spacing: bool,
+    /// Left/right indents are inside/outside: they swap on even pages.
+    pub mirror_indents: bool,
     pub keep_next: bool,
     pub keep_lines: bool,
     pub page_break_before: bool,
@@ -144,6 +154,7 @@ pub struct ResolvedPara {
     pub bidi: bool,
     pub drop_cap: u8,
     pub suppress_hyphens: bool,
+    pub suppress_line_numbers: bool,
     /// Asian typography (see `ParaProps`): East Asian line-breaking rules.
     pub kinsoku: bool,
     /// Latin words wrap whole (`false`: they may break at any character).
@@ -154,6 +165,10 @@ pub struct ResolvedPara {
     pub auto_space_dn: bool,
     /// Lines snap to the document grid, when the section has one.
     pub snap_to_grid: bool,
+    /// Indents in characters (left, right, first line; 0 = in points), which win over the
+    /// point values; see [`ResolvedPara::set_char_unit`].
+    #[serde(default)]
+    pub indent_chars: [f32; 3],
 }
 
 const MAX_INDENT: f32 = 1584.0; // 22"
@@ -165,6 +180,18 @@ impl ResolvedPara {
     pub fn visual_indents(&self) -> (f32, f32) {
         if self.bidi { (self.indent_right, self.indent_left) } else { (self.indent_left, self.indent_right) }
     }
+
+    /// Turn the indents given in characters into points, one character being `size` points: the
+    /// size of the paragraph mark's font (as Word measures `w:firstLineChars` and friends).
+    pub fn set_char_unit(&mut self, size: f32) {
+        let size = if size.is_finite() { size.clamp(1.0, 1638.0) } else { 12.0 };
+        let [l, r, f] = self.indent_chars;
+        for (chars, pts) in [(l, &mut self.indent_left), (r, &mut self.indent_right), (f, &mut self.indent_first)] {
+            if chars != 0.0 {
+                *pts = (chars * size).clamp(-MAX_INDENT, MAX_INDENT);
+            }
+        }
+    }
 }
 
 impl ResolvedPara {
@@ -187,6 +214,7 @@ impl ResolvedPara {
                 LineSpacing::Exactly(v) => LineSpacing::Exactly(if v.is_finite() { v.clamp(0.7, 1584.0) } else { 12.0 }),
             },
             contextual_spacing: p.contextual_spacing.unwrap_or(false),
+            mirror_indents: p.mirror_indents.unwrap_or(false),
             keep_next: p.keep_next.unwrap_or(false),
             keep_lines: p.keep_lines.unwrap_or(false),
             page_break_before: p.page_break_before.unwrap_or(false),
@@ -199,6 +227,7 @@ impl ResolvedPara {
             bidi: p.bidi.unwrap_or(false),
             drop_cap: p.drop_cap.unwrap_or(0).min(10),
             suppress_hyphens: p.suppress_hyphens.unwrap_or(false),
+            suppress_line_numbers: p.suppress_line_numbers.unwrap_or(false),
             kinsoku: p.kinsoku.unwrap_or(true),
             word_wrap: p.word_wrap.unwrap_or(true),
             overflow_punct: p.overflow_punct.unwrap_or(true),
@@ -206,10 +235,15 @@ impl ResolvedPara {
             auto_space_de: p.auto_space_de.unwrap_or(true),
             auto_space_dn: p.auto_space_dn.unwrap_or(true),
             snap_to_grid: p.snap_to_grid.unwrap_or(true),
+            indent_chars: [p.indent_left_chars, p.indent_right_chars, p.indent_first_chars]
+                .map(|c| c.filter(|c| c.is_finite()).unwrap_or(0.0).clamp(-MAX_CHARS, MAX_CHARS)),
         }
     }
 }
 
+/// The largest indent in characters (Word allows indents up to 22").
+const MAX_CHARS: f32 = 1584.0;
+
 impl StyleSheet {
     /// Paragraph properties after defaults and the style chain (without direct formatting).
     pub fn para_style_props(&self, style: &str) -> (ParaProps, CharProps) {
@@ -259,7 +293,13 @@ impl StyleSheet {
             direct.tabs = Some(merged);
         }
         base.overlay(&direct);
-        ResolvedPara::from(&base, &style)
+        let mut rp = ResolvedPara::from(&base, &style);
+        // Indents in characters: measured in the style's font size here; layout measures them in
+        // the paragraph mark's (`set_char_unit`), which direct formatting may change.
+        if rp.indent_chars.iter().any(|c| *c != 0.0) {
+            rp.set_char_unit(self.resolve_char(Some(&style), &CharProps::default()).size);
+        }
+        rp
     }
 
     /// Resolve character formatting for a run in a paragraph of style `para_style`.
diff --git a/crates/doc/src/section.rs b/crates/doc/src/section.rs
index 1c546c137e..60f712394b 100644
--- a/crates/doc/src/section.rs
+++ b/crates/doc/src/section.rs
@@ -15,6 +15,9 @@ pub enum SectionStart {
     NextColumn,
 }
 
+/// A number format (ECMA-376 §17.18.59 ST_NumberFormat). Every value the format defines is
+/// kept, so a document saves back the format it was opened with even where WordCraft draws it as
+/// plain decimal (see [`NumFormat::format`]).
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, Default)]
 #[serde(rename_all = "camelCase")]
 pub enum NumFormat {
@@ -30,9 +33,127 @@ pub enum NumFormat {
     DecimalZero,
     Bullet,
     None,
+    Hex,
+    Chicago,
+    IdeographDigital,
+    JapaneseCounting,
+    Aiueo,
+    Iroha,
+    DecimalFullWidth,
+    DecimalHalfWidth,
+    JapaneseLegal,
+    JapaneseDigitalTenThousand,
+    DecimalEnclosedCircle,
+    DecimalFullWidth2,
+    AiueoFullWidth,
+    IrohaFullWidth,
+    Ganada,
+    Chosung,
+    DecimalEnclosedFullstop,
+    DecimalEnclosedParen,
+    DecimalEnclosedCircleChinese,
+    IdeographEnclosedCircle,
+    IdeographTraditional,
+    IdeographZodiac,
+    IdeographZodiacTraditional,
+    TaiwaneseCounting,
+    IdeographLegalTraditional,
+    TaiwaneseCountingThousand,
+    TaiwaneseDigital,
+    ChineseCounting,
+    ChineseLegalSimplified,
+    ChineseCountingThousand,
+    KoreanDigital,
+    KoreanCounting,
+    KoreanLegal,
+    KoreanDigital2,
+    VietnameseCounting,
+    RussianLower,
+    RussianUpper,
+    NumberInDash,
+    Hebrew1,
+    Hebrew2,
+    ArabicAlpha,
+    ArabicAbjad,
+    HindiVowels,
+    HindiConsonants,
+    HindiNumbers,
+    HindiCounting,
+    ThaiLetters,
+    ThaiNumbers,
+    ThaiCounting,
+    BahtText,
+    DollarText,
 }
 
 impl NumFormat {
+    /// Every format, in the order ST_NumberFormat lists them (which is also the order of the
+    /// binary .doc number format codes up to 0x27).
+    pub const ALL: [NumFormat; 62] = [
+        NumFormat::Decimal,
+        NumFormat::UpperRoman,
+        NumFormat::LowerRoman,
+        NumFormat::UpperLetter,
+        NumFormat::LowerLetter,
+        NumFormat::Ordinal,
+        NumFormat::CardinalText,
+        NumFormat::OrdinalText,
+        NumFormat::Hex,
+        NumFormat::Chicago,
+        NumFormat::IdeographDigital,
+        NumFormat::JapaneseCounting,
+        NumFormat::Aiueo,
+        NumFormat::Iroha,
+        NumFormat::DecimalFullWidth,
+        NumFormat::DecimalHalfWidth,
+        NumFormat::JapaneseLegal,
+        NumFormat::JapaneseDigitalTenThousand,
+        NumFormat::DecimalEnclosedCircle,
+        NumFormat::DecimalFullWidth2,
+        NumFormat::AiueoFullWidth,
+        NumFormat::IrohaFullWidth,
+        NumFormat::DecimalZero,
+        NumFormat::Bullet,
+        NumFormat::Ganada,
+        NumFormat::Chosung,
+        NumFormat::DecimalEnclosedFullstop,
+        NumFormat::DecimalEnclosedParen,
+        NumFormat::DecimalEnclosedCircleChinese,
+        NumFormat::IdeographEnclosedCircle,
+        NumFormat::IdeographTraditional,
+        NumFormat::IdeographZodiac,
+        NumFormat::IdeographZodiacTraditional,
+        NumFormat::TaiwaneseCounting,
+        NumFormat::IdeographLegalTraditional,
+        NumFormat::TaiwaneseCountingThousand,
+        NumFormat::TaiwaneseDigital,
+        NumFormat::ChineseCounting,
+        NumFormat::ChineseLegalSimplified,
+        NumFormat::ChineseCountingThousand,
+        NumFormat::KoreanDigital,
+        NumFormat::KoreanCounting,
+        NumFormat::KoreanLegal,
+        NumFormat::KoreanDigital2,
+        NumFormat::VietnameseCounting,
+        NumFormat::RussianLower,
+        NumFormat::RussianUpper,
+        NumFormat::None,
+        NumFormat::NumberInDash,
+        NumFormat::Hebrew1,
+        NumFormat::Hebrew2,
+        NumFormat::ArabicAlpha,
+        NumFormat::ArabicAbjad,
+        NumFormat::HindiVowels,
+        NumFormat::HindiConsonants,
+        NumFormat::HindiNumbers,
+        NumFormat::HindiCounting,
+        NumFormat::ThaiLetters,
+        NumFormat::ThaiNumbers,
+        NumFormat::ThaiCounting,
+        NumFormat::BahtText,
+        NumFormat::DollarText,
+    ];
+
     pub fn ooxml(self) -> &'static str {
         match self {
             NumFormat::Decimal => "decimal",
@@ -46,30 +167,71 @@ impl NumFormat {
             NumFormat::DecimalZero => "decimalZero",
             NumFormat::Bullet => "bullet",
             NumFormat::None => "none",
+            NumFormat::Hex => "hex",
+            NumFormat::Chicago => "chicago",
+            NumFormat::IdeographDigital => "ideographDigital",
+            NumFormat::JapaneseCounting => "japaneseCounting",
+            NumFormat::Aiueo => "aiueo",
+            NumFormat::Iroha => "iroha",
+            NumFormat::DecimalFullWidth => "decimalFullWidth",
+            NumFormat::DecimalHalfWidth => "decimalHalfWidth",
+            NumFormat::JapaneseLegal => "japaneseLegal",
+            NumFormat::JapaneseDigitalTenThousand => "japaneseDigitalTenThousand",
+            NumFormat::DecimalEnclosedCircle => "decimalEnclosedCircle",
+            NumFormat::DecimalFullWidth2 => "decimalFullWidth2",
+            NumFormat::AiueoFullWidth => "aiueoFullWidth",
+            NumFormat::IrohaFullWidth => "irohaFullWidth",
+            NumFormat::Ganada => "ganada",
+            NumFormat::Chosung => "chosung",
+            NumFormat::DecimalEnclosedFullstop => "decimalEnclosedFullstop",
+            NumFormat::DecimalEnclosedParen => "decimalEnclosedParen",
+            NumFormat::DecimalEnclosedCircleChinese => "decimalEnclosedCircleChinese",
+            NumFormat::IdeographEnclosedCircle => "ideographEnclosedCircle",
+            NumFormat::IdeographTraditional => "ideographTraditional",
+            NumFormat::IdeographZodiac => "ideographZodiac",
+            NumFormat::IdeographZodiacTraditional => "ideographZodiacTraditional",
+            NumFormat::TaiwaneseCounting => "taiwaneseCounting",
+            NumFormat::IdeographLegalTraditional => "ideographLegalTraditional",
+            NumFormat::TaiwaneseCountingThousand => "taiwaneseCountingThousand",
+            NumFormat::TaiwaneseDigital => "taiwaneseDigital",
+            NumFormat::ChineseCounting => "chineseCounting",
+            NumFormat::ChineseLegalSimplified => "chineseLegalSimplified",
+            NumFormat::ChineseCountingThousand => "chineseCountingThousand",
+            NumFormat::KoreanDigital => "koreanDigital",
+            NumFormat::KoreanCounting => "koreanCounting",
+            NumFormat::KoreanLegal => "koreanLegal",
+            NumFormat::KoreanDigital2 => "koreanDigital2",
+            NumFormat::VietnameseCounting => "vietnameseCounting",
+            NumFormat::RussianLower => "russianLower",
+            NumFormat::RussianUpper => "russianUpper",
+            NumFormat::NumberInDash => "numberInDash",
+            NumFormat::Hebrew1 => "hebrew1",
+            NumFormat::Hebrew2 => "hebrew2",
+            NumFormat::ArabicAlpha => "arabicAlpha",
+            NumFormat::ArabicAbjad => "arabicAbjad",
+            NumFormat::HindiVowels => "hindiVowels",
+            NumFormat::HindiConsonants => "hindiConsonants",
+            NumFormat::HindiNumbers => "hindiNumbers",
+            NumFormat::HindiCounting => "hindiCounting",
+            NumFormat::ThaiLetters => "thaiLetters",
+            NumFormat::ThaiNumbers => "thaiNumbers",
+            NumFormat::ThaiCounting => "thaiCounting",
+            NumFormat::BahtText => "bahtText",
+            NumFormat::DollarText => "dollarText",
         }
     }
+    /// The format an ST_NumberFormat value names; a value the format doesn't define is decimal
+    /// (as Word shows it). So is `custom` (a Word 2010 format string, always written with a
+    /// decimal fallback).
     pub fn from_ooxml(s: &str) -> NumFormat {
-        [
-            NumFormat::Decimal,
-            NumFormat::UpperRoman,
-            NumFormat::LowerRoman,
-            NumFormat::UpperLetter,
-            NumFormat::LowerLetter,
-            NumFormat::Ordinal,
-            NumFormat::CardinalText,
-            NumFormat::OrdinalText,
-            NumFormat::DecimalZero,
-            NumFormat::Bullet,
-            NumFormat::None,
-        ]
-        .into_iter()
-        .find(|f| f.ooxml() == s)
-        .unwrap_or(NumFormat::Decimal)
+        NumFormat::ALL.into_iter().find(|f| f.ooxml() == s).unwrap_or(NumFormat::Decimal)
     }
-    /// Format `n` (1-based).
+    /// Format `n` (1-based). Formats WordCraft doesn't draw yet (Hebrew, Arabic, Hindi, Thai,
+    /// Vietnamese, Russian, text amounts) show decimal, as do values past a sequence's end
+    /// (the 21st item of ①…⑳).
     pub fn format(self, n: u32) -> String {
+        use crate::cjk_numbers as cjk;
         match self {
-            NumFormat::Decimal => n.to_string(),
             NumFormat::DecimalZero => format!("{n:02}"),
             NumFormat::UpperRoman => roman(n).to_uppercase(),
             NumFormat::LowerRoman => roman(n),
@@ -79,10 +241,70 @@ impl NumFormat {
             NumFormat::CardinalText => cardinal_text(n),
             NumFormat::OrdinalText => ordinal_text(n),
             NumFormat::Bullet | NumFormat::None => String::new(),
+            NumFormat::Chicago => chicago(n),
+            NumFormat::NumberInDash => format!("- {n} -"),
+            NumFormat::IdeographDigital | NumFormat::KoreanDigital2 | NumFormat::TaiwaneseDigital => cjk::ideograph_digital(n),
+            NumFormat::JapaneseCounting => cjk::japanese_counting(n),
+            NumFormat::JapaneseLegal => cjk::japanese_legal(n),
+            NumFormat::JapaneseDigitalTenThousand => cjk::japanese_digital_ten_thousand(n),
+            NumFormat::Aiueo => cjk::aiueo(n),
+            NumFormat::AiueoFullWidth => cjk::aiueo_full_width(n),
+            NumFormat::Iroha => cjk::iroha(n),
+            NumFormat::IrohaFullWidth => cjk::iroha_full_width(n),
+            NumFormat::DecimalFullWidth | NumFormat::DecimalFullWidth2 => cjk::decimal_full_width(n),
+            NumFormat::DecimalEnclosedCircle => cjk::decimal_enclosed_circle(n),
+            NumFormat::DecimalEnclosedCircleChinese => cjk::decimal_enclosed_circle_chinese(n),
+            NumFormat::DecimalEnclosedFullstop => cjk::decimal_enclosed_fullstop(n),
+            NumFormat::DecimalEnclosedParen => cjk::decimal_enclosed_paren(n),
+            NumFormat::IdeographEnclosedCircle => cjk::ideograph_enclosed_circle(n),
+            NumFormat::IdeographTraditional => cjk::ideograph_traditional(n),
+            NumFormat::IdeographZodiac => cjk::ideograph_zodiac(n),
+            NumFormat::IdeographZodiacTraditional => cjk::ideograph_zodiac_traditional(n),
+            NumFormat::IdeographLegalTraditional => cjk::ideograph_legal_traditional(n),
+            NumFormat::TaiwaneseCounting => cjk::taiwanese_counting(n),
+            NumFormat::TaiwaneseCountingThousand => cjk::taiwanese_counting_thousand(n),
+            NumFormat::ChineseCounting => cjk::chinese_counting(n),
+            NumFormat::ChineseCountingThousand => cjk::chinese_counting_thousand(n),
+            NumFormat::ChineseLegalSimplified => cjk::chinese_legal_simplified(n),
+            NumFormat::KoreanCounting => cjk::korean_counting(n),
+            NumFormat::KoreanDigital => cjk::korean_digital(n),
+            NumFormat::KoreanLegal => cjk::korean_legal(n),
+            NumFormat::Ganada => cjk::ganada(n),
+            NumFormat::Chosung => cjk::chosung(n),
+            NumFormat::Decimal
+            | NumFormat::DecimalHalfWidth
+            | NumFormat::Hex
+            | NumFormat::VietnameseCounting
+            | NumFormat::RussianLower
+            | NumFormat::RussianUpper
+            | NumFormat::Hebrew1
+            | NumFormat::Hebrew2
+            | NumFormat::ArabicAlpha
+            | NumFormat::ArabicAbjad
+            | NumFormat::HindiVowels
+            | NumFormat::HindiConsonants
+            | NumFormat::HindiNumbers
+            | NumFormat::HindiCounting
+            | NumFormat::ThaiLetters
+            | NumFormat::ThaiNumbers
+            | NumFormat::ThaiCounting
+            | NumFormat::BahtText
+            | NumFormat::DollarText => n.to_string(),
         }
     }
 }
 
+/// Chicago Manual of Style note marks: *, †, ‡, §, then doubled (**, ††, …) and so on.
+fn chicago(n: u32) -> String {
+    const MARKS: [char; 4] = ['*', '\u{2020}', '\u{2021}', '\u{a7}'];
+    if n == 0 {
+        return String::new();
+    }
+    let i = (n - 1) as usize;
+    let k = (i / 4 + 1).min(10);
+    std::iter::repeat_n(MARKS.get(i % 4).copied().unwrap_or('*'), k).collect()
+}
+
 fn ordinal_suffix(n: u32) -> &'static str {
     match (n % 10, n % 100) {
         (_, 11..=13) => "th",
@@ -459,6 +681,10 @@ pub struct SectionProps {
     pub page_borders: Option<Borders>,
     /// Text direction / bidi section.
     pub rtl: bool,
+    /// Which way the section's text runs (`w:textDirection`, ECMA-376 §17.6.20): vertical
+    /// sections turn the page's text area (headers and footers stay horizontal).
+    #[serde(skip_serializing_if = "is_horizontal")]
+    pub text_direction: crate::props::TextDirection,
     /// Tracked change of the section's properties (`w:sectPrChange`).
     #[serde(skip_serializing_if = "Option::is_none")]
     pub fmt_change: Option<Box<crate::props::PropChange<SectionProps>>>,
@@ -496,6 +722,7 @@ impl Default for SectionProps {
             valign: VAlign::Top,
             page_borders: None,
             rtl: false,
+            text_direction: crate::props::TextDirection::Horizontal,
             fmt_change: None,
             doc_grid: None,
             footnote_pr: NoteProps::default(),
@@ -504,6 +731,10 @@ impl Default for SectionProps {
     }
 }
 
+fn is_horizontal(d: &crate::props::TextDirection) -> bool {
+    !d.is_turned()
+}
+
 impl SectionProps {
     /// Width of the text area, points.
     pub fn text_width(&self) -> f32 {
@@ -595,6 +826,16 @@ mod tests {
         assert_eq!(NumFormat::DecimalZero.format(3), "03");
         assert!(!NumFormat::UpperRoman.format(u32::MAX).is_empty());
         assert_eq!(NumFormat::LowerLetter.format(u32::MAX).len(), 30);
+        assert_eq!([NumFormat::Chicago.format(1), NumFormat::Chicago.format(6)], ["*", "\u{2020}\u{2020}"]);
+        assert_eq!(NumFormat::ChineseCounting.format(11), "十一");
+        assert_eq!(NumFormat::ChineseCountingThousand.format(101), "一百零一");
+        assert_eq!(NumFormat::DecimalEnclosedCircle.format(3), "③");
+        assert_eq!(NumFormat::Hebrew1.format(3), "3", "formats not drawn yet show decimal");
+        for f in NumFormat::ALL {
+            assert_eq!(NumFormat::from_ooxml(f.ooxml()), f, "{f:?} round-trips");
+            assert!(f == NumFormat::Bullet || f == NumFormat::None || !f.format(u32::MAX).is_empty(), "{f:?}");
+        }
+        assert_eq!(NumFormat::from_ooxml("klingon"), NumFormat::Decimal, "unknown formats are decimal");
     }
 
     #[test]
diff --git a/crates/doc/src/smart_art.rs b/crates/doc/src/smart_art.rs
new file mode 100644
index 0000000000..43b9105ca0
--- /dev/null
+++ b/crates/doc/src/smart_art.rs
@@ -0,0 +1,324 @@
+//! SmartArt graphics WordCraft makes and edits (Insert › SmartArt): a layout, an outline of items
+//! (text and level) and a colour variant.
+//!
+//! A SmartArt object ([`crate::graphic::Graphic`] with `smart_art` set) keeps this model next to
+//! the items it is drawn with. WordCraft lays it out with its own algorithms; the DOCX writer
+//! saves it as diagram parts (data, layout, style, colours and the drawing of the shapes) and the
+//! reader turns a diagram back into it only when its data part is exactly what WordCraft writes.
+//! SmartArt from other programs stays as it was read.
+//!
+//! Every value from outside (commands, files) goes through [`SmartArtSpec::sanitize`]: item
+//! count, text length and levels are capped.
+
+use serde::{Deserialize, Serialize};
+
+/// Most items in a SmartArt graphic.
+pub const MAX_ITEMS: usize = 100;
+/// Longest item text, characters.
+pub const MAX_TEXT: usize = 255;
+/// Deepest item level (0 is the top).
+pub const MAX_LEVEL: u8 = 7;
+
+/// How a SmartArt graphic arranges its items.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum SmartArtLayout {
+    /// Blocks in rows.
+    #[default]
+    BasicList,
+    /// Steps left to right with arrows between.
+    Process,
+    /// Steps around a circle with arrows between.
+    Cycle,
+    /// A tree: each item under the item one level up before it.
+    Hierarchy,
+    /// Stacked bands narrowing to the top.
+    Pyramid,
+    /// The first item in the middle, the items under it around it.
+    Radial,
+    /// Quadrants of a square.
+    Matrix,
+    /// Overlapping circles.
+    Venn,
+}
+
+impl SmartArtLayout {
+    pub const ALL: [SmartArtLayout; 8] = [
+        SmartArtLayout::BasicList,
+        SmartArtLayout::Process,
+        SmartArtLayout::Cycle,
+        SmartArtLayout::Hierarchy,
+        SmartArtLayout::Pyramid,
+        SmartArtLayout::Radial,
+        SmartArtLayout::Matrix,
+        SmartArtLayout::Venn,
+    ];
+
+    /// The id commands use (`basicList`, `process`…).
+    pub fn id(self) -> &'static str {
+        match self {
+            SmartArtLayout::BasicList => "basicList",
+            SmartArtLayout::Process => "process",
+            SmartArtLayout::Cycle => "cycle",
+            SmartArtLayout::Hierarchy => "hierarchy",
+            SmartArtLayout::Pyramid => "pyramid",
+            SmartArtLayout::Radial => "radial",
+            SmartArtLayout::Matrix => "matrix",
+            SmartArtLayout::Venn => "venn",
+        }
+    }
+
+    /// The layout an id names (any ASCII case; `list` is the basic list).
+    pub fn from_id(id: &str) -> Option<SmartArtLayout> {
+        let id = id.trim();
+        if id.eq_ignore_ascii_case("list") {
+            return Some(SmartArtLayout::BasicList);
+        }
+        SmartArtLayout::ALL.into_iter().find(|l| l.id().eq_ignore_ascii_case(id))
+    }
+
+    /// The name shown for it.
+    pub fn label(self) -> &'static str {
+        match self {
+            SmartArtLayout::BasicList => "Basic List",
+            SmartArtLayout::Process => "Basic Process",
+            SmartArtLayout::Cycle => "Basic Cycle",
+            SmartArtLayout::Hierarchy => "Hierarchy",
+            SmartArtLayout::Pyramid => "Basic Pyramid",
+            SmartArtLayout::Radial => "Basic Radial",
+            SmartArtLayout::Matrix => "Basic Matrix",
+            SmartArtLayout::Venn => "Basic Venn",
+        }
+    }
+
+    /// The gallery category it's shown under.
+    pub fn category(self) -> &'static str {
+        match self {
+            SmartArtLayout::BasicList => "List",
+            SmartArtLayout::Process => "Process",
+            SmartArtLayout::Cycle => "Cycle",
+            SmartArtLayout::Hierarchy => "Hierarchy",
+            SmartArtLayout::Pyramid => "Pyramid",
+            SmartArtLayout::Radial | SmartArtLayout::Venn => "Relationship",
+            SmartArtLayout::Matrix => "Matrix",
+        }
+    }
+
+    /// What it's for, in a sentence (the picker shows it).
+    pub fn description(self) -> &'static str {
+        match self {
+            SmartArtLayout::BasicList => "Shows items of equal weight as blocks in rows.",
+            SmartArtLayout::Process => "Shows steps in order, left to right, with arrows between them.",
+            SmartArtLayout::Cycle => "Shows steps that repeat, around a circle.",
+            SmartArtLayout::Hierarchy => "Shows a tree: each item below the item it belongs to.",
+            SmartArtLayout::Pyramid => "Shows parts that build on each other, largest at the bottom.",
+            SmartArtLayout::Radial => "Shows items around a central idea: the first item is the centre.",
+            SmartArtLayout::Matrix => "Shows parts of a whole as quadrants.",
+            SmartArtLayout::Venn => "Shows overlapping ideas as overlapping circles.",
+        }
+    }
+}
+
+/// The colours a SmartArt graphic takes from the document's theme.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum SmartArtColors {
+    /// Every shape in accent `n` (1–6).
+    #[default]
+    Accent1,
+    Accent2,
+    Accent3,
+    Accent4,
+    Accent5,
+    Accent6,
+    /// Shapes take the accents in turn.
+    Colorful,
+}
+
+impl SmartArtColors {
+    pub const ALL: [SmartArtColors; 7] = [
+        SmartArtColors::Accent1,
+        SmartArtColors::Accent2,
+        SmartArtColors::Accent3,
+        SmartArtColors::Accent4,
+        SmartArtColors::Accent5,
+        SmartArtColors::Accent6,
+        SmartArtColors::Colorful,
+    ];
+
+    pub fn id(self) -> &'static str {
+        match self {
+            SmartArtColors::Accent1 => "accent1",
+            SmartArtColors::Accent2 => "accent2",
+            SmartArtColors::Accent3 => "accent3",
+            SmartArtColors::Accent4 => "accent4",
+            SmartArtColors::Accent5 => "accent5",
+            SmartArtColors::Accent6 => "accent6",
+            SmartArtColors::Colorful => "colorful",
+        }
+    }
+
+    pub fn from_id(id: &str) -> Option<SmartArtColors> {
+        SmartArtColors::ALL.into_iter().find(|c| c.id().eq_ignore_ascii_case(id.trim()))
+    }
+
+    /// The name shown for it.
+    pub fn label(self) -> &'static str {
+        match self {
+            SmartArtColors::Accent1 => "Accent 1",
+            SmartArtColors::Accent2 => "Accent 2",
+            SmartArtColors::Accent3 => "Accent 3",
+            SmartArtColors::Accent4 => "Accent 4",
+            SmartArtColors::Accent5 => "Accent 5",
+            SmartArtColors::Accent6 => "Accent 6",
+            SmartArtColors::Colorful => "Colorful",
+        }
+    }
+
+    /// The theme accent (1–6) of shape `i`.
+    pub fn accent(self, i: usize) -> usize {
+        match self {
+            SmartArtColors::Accent1 => 1,
+            SmartArtColors::Accent2 => 2,
+            SmartArtColors::Accent3 => 3,
+            SmartArtColors::Accent4 => 4,
+            SmartArtColors::Accent5 => 5,
+            SmartArtColors::Accent6 => 6,
+            SmartArtColors::Colorful => i % 6 + 1,
+        }
+    }
+}
+
+/// One item of the outline: its text and level (0 is the top).
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SmartArtItem {
+    pub text: String,
+    #[serde(default)]
+    pub level: u8,
+}
+
+impl SmartArtItem {
+    pub fn new(text: impl Into<String>, level: u8) -> SmartArtItem {
+        SmartArtItem { text: text.into(), level }
+    }
+}
+
+/// A SmartArt graphic WordCraft can edit.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SmartArtSpec {
+    pub layout: SmartArtLayout,
+    #[serde(default)]
+    pub items: Vec<SmartArtItem>,
+    #[serde(default)]
+    pub colors: SmartArtColors,
+}
+
+impl SmartArtSpec {
+    /// A new graphic of `layout` with WordCraft's sample items.
+    pub fn sample(layout: SmartArtLayout) -> SmartArtSpec {
+        let items: Vec<SmartArtItem> = match layout {
+            SmartArtLayout::Hierarchy => vec![
+                SmartArtItem::new("Lead", 0),
+                SmartArtItem::new("Design", 1),
+                SmartArtItem::new("Sketches", 2),
+                SmartArtItem::new("Build", 1),
+                SmartArtItem::new("Code", 2),
+                SmartArtItem::new("Tests", 2),
+            ],
+            SmartArtLayout::Radial => {
+                let mut v = vec![SmartArtItem::new("Goal", 0)];
+                v.extend(["Plan", "Build", "Test", "Ship"].map(|t| SmartArtItem::new(t, 1)));
+                v
+            }
+            SmartArtLayout::Process | SmartArtLayout::Cycle => ["Plan", "Build", "Test", "Ship"].map(|t| SmartArtItem::new(t, 0)).to_vec(),
+            SmartArtLayout::Pyramid | SmartArtLayout::Venn => ["People", "Process", "Tools"].map(|t| SmartArtItem::new(t, 0)).to_vec(),
+            SmartArtLayout::Matrix => ["Strengths", "Weaknesses", "Chances", "Risks"].map(|t| SmartArtItem::new(t, 0)).to_vec(),
+            SmartArtLayout::BasicList => ["Ideas", "Notes", "Drafts", "Edits", "Final"].map(|t| SmartArtItem::new(t, 0)).to_vec(),
+        };
+        SmartArtSpec { layout, items, colors: SmartArtColors::default() }
+    }
+
+    /// Make the graphic safe to store and draw: at most [`MAX_ITEMS`] items, text cut to
+    /// [`MAX_TEXT`] characters with control characters as spaces and the ends trimmed, and levels
+    /// that follow on (the first item at level 0, each item at most one level below the one
+    /// before it, never below [`MAX_LEVEL`]).
+    pub fn sanitize(&mut self) {
+        self.items.truncate(MAX_ITEMS);
+        let mut prev: Option<u8> = None;
+        for it in &mut self.items {
+            it.text = clean_text(&it.text);
+            let most = prev.map_or(0, |p| p.saturating_add(1)).min(MAX_LEVEL);
+            it.level = it.level.min(most);
+            prev = Some(it.level);
+        }
+    }
+
+    /// The graphic after `sanitize`.
+    pub fn sanitized(mut self) -> SmartArtSpec {
+        self.sanitize();
+        self
+    }
+
+    /// The index of the item each item belongs to (the nearest item before it one level up);
+    /// `None` for the top-level items. Expects a sanitized graphic.
+    pub fn parents(&self) -> Vec<Option<usize>> {
+        let mut out = Vec::with_capacity(self.items.len());
+        // The last item seen at each level.
+        let mut last: Vec<usize> = Vec::new();
+        for (i, it) in self.items.iter().enumerate() {
+            let l = usize::from(it.level);
+            last.truncate(l);
+            out.push(if l == 0 { None } else { last.last().copied() });
+            last.push(i);
+        }
+        out
+    }
+
+    /// The items that belong to item `i` (directly or deeper): the run after it at deeper levels.
+    pub fn descendants(&self, i: usize) -> std::ops::Range<usize> {
+        let Some(level) = self.items.get(i).map(|it| it.level) else { return 0..0 };
+        let start = i + 1;
+        let end = self.items.iter().skip(start).position(|it| it.level <= level).map_or(self.items.len(), |p| start + p);
+        start..end
+    }
+}
+
+/// `s` as item text: control characters as spaces, ends trimmed, at most [`MAX_TEXT`] characters.
+pub fn clean_text(s: &str) -> String {
+    let s: String = s.chars().take(MAX_TEXT * 4).map(|c| if c.is_control() { ' ' } else { c }).collect();
+    s.trim().chars().take(MAX_TEXT).collect::<String>().trim_end().to_string()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sanitize_caps_items_text_and_levels() {
+        let mut s = SmartArtSpec {
+            items: (0..MAX_ITEMS + 20).map(|i| SmartArtItem::new(format!("{}\n{i}", "x".repeat(400)), if i == 0 { 5 } else { 200 })).collect(),
+            ..Default::default()
+        };
+        s.sanitize();
+        assert_eq!(s.items.len(), MAX_ITEMS);
+        assert_eq!(s.items[0].level, 0, "the first item is at the top");
+        assert_eq!(s.items[1].level, 1, "one level below the item before");
+        assert!(s.items.iter().all(|it| it.level <= MAX_LEVEL));
+        assert_eq!(s.items[0].text.chars().count(), MAX_TEXT);
+        assert!(!s.items[0].text.contains('\n'));
+    }
+
+    #[test]
+    fn parents_and_descendants_follow_levels() {
+        let s = SmartArtSpec::sample(SmartArtLayout::Hierarchy).sanitized();
+        assert_eq!(s.parents(), vec![None, Some(0), Some(1), Some(0), Some(3), Some(3)]);
+        assert_eq!(s.descendants(0), 1..6);
+        assert_eq!(s.descendants(1), 2..3);
+        assert_eq!(s.descendants(5), 6..6);
+        assert_eq!(s.descendants(99), 0..0);
+        assert_eq!(SmartArtLayout::from_id("VENN"), Some(SmartArtLayout::Venn));
+        assert_eq!(SmartArtColors::from_id("colorful"), Some(SmartArtColors::Colorful));
+    }
+}
diff --git a/crates/doc/src/styles.rs b/crates/doc/src/styles.rs
index 806b9eb6ea..0053c03e59 100644
--- a/crates/doc/src/styles.rs
+++ b/crates/doc/src/styles.rs
@@ -37,6 +37,10 @@ pub struct Style {
     pub hidden: bool,
     /// Built in (cannot be deleted).
     pub builtin: bool,
+    /// Can't be applied while Restrict Editing limits formatting to a selection of styles
+    /// (`w:locked`).
+    #[serde(skip_serializing_if = "std::ops::Not::not")]
+    pub locked: bool,
     /// Table style: conditional formatting for header row, banding etc.
     pub table: Option<TableStyleParts>,
 }
@@ -134,6 +138,9 @@ pub struct StyleSheet {
     /// Document defaults (`w:docDefaults`).
     pub default_chr: CharProps,
     pub default_para: ParaProps,
+    /// Preserve an explicit `w:pPrDefault`, even when empty. Omission leaves defaults to
+    /// the application; nonempty `default_para` is always written after spacing edits.
+    pub default_para_present: bool,
     pub styles: Vec<Style>,
 }
 
@@ -161,7 +168,7 @@ fn color(c: Rgb) -> Option<TextColor> {
 
 impl StyleSheet {
     pub fn empty() -> Self {
-        StyleSheet { default_chr: CharProps::default(), default_para: ParaProps::default(), styles: Vec::new() }
+        StyleSheet { default_chr: CharProps::default(), default_para: ParaProps::default(), default_para_present: true, styles: Vec::new() }
     }
 
     /// The built-in style set used for new documents.
@@ -175,6 +182,7 @@ impl StyleSheet {
                 widow_control: Some(true),
                 ..para()
             },
+            default_para_present: true,
             styles: Vec::new(),
         };
         let mut add = |st: Style| s.styles.push(st);
@@ -584,6 +592,18 @@ mod tests {
         assert!(g.iter().any(|s| s.id == "Heading1"));
     }
 
+    #[test]
+    fn older_serialized_styles_keep_explicit_defaults() {
+        let mut value = serde_json::to_value(StyleSheet::empty()).unwrap();
+        value.as_object_mut().unwrap().remove("defaultParaPresent");
+        let sheet: StyleSheet = serde_json::from_value(value).unwrap();
+        assert!(sheet.default_para_present);
+        let mut omitted = sheet;
+        omitted.default_para_present = false;
+        let again: StyleSheet = serde_json::from_str(&serde_json::to_string(&omitted).unwrap()).unwrap();
+        assert_eq!(again, omitted);
+    }
+
     #[test]
     fn chain_is_cycle_safe() {
         let mut s = StyleSheet::builtin();
diff --git a/crates/doc/src/table.rs b/crates/doc/src/table.rs
index 6fe7f3e55a..104bf96b82 100644
--- a/crates/doc/src/table.rs
+++ b/crates/doc/src/table.rs
@@ -3,6 +3,7 @@
 
 use serde::{Deserialize, Serialize};
 
+use crate::control::ControlWrap;
 use crate::props::{CellProps, RowProps, TableProps, VMerge};
 use crate::{Blocks, Paragraph, para_block};
 
@@ -11,14 +12,21 @@ pub struct Cell {
     #[serde(default)]
     pub props: CellProps,
     pub blocks: Blocks,
+    /// Content controls around the cell (see [`crate::control`]).
+    #[serde(default, skip_serializing_if = "ControlWrap::is_empty")]
+    pub controls: ControlWrap,
 }
 
 impl Cell {
     pub fn empty() -> Cell {
-        Cell { props: CellProps { span: 1, ..Default::default() }, blocks: vec![para_block(Paragraph::new())] }
+        Cell { props: CellProps { span: 1, ..Default::default() }, blocks: vec![para_block(Paragraph::new())], controls: ControlWrap::default() }
     }
     pub fn with_text(s: &str) -> Cell {
-        Cell { props: CellProps { span: 1, ..Default::default() }, blocks: vec![para_block(Paragraph::with_text(s, Default::default()))] }
+        Cell {
+            props: CellProps { span: 1, ..Default::default() },
+            blocks: vec![para_block(Paragraph::with_text(s, Default::default()))],
+            controls: ControlWrap::default(),
+        }
     }
     pub fn span(&self) -> usize {
         self.props.span.clamp(1, 63) as usize
@@ -30,6 +38,9 @@ pub struct Row {
     #[serde(default)]
     pub props: RowProps,
     pub cells: Vec<Cell>,
+    /// Content controls around the row (repeating sections; see [`crate::control`]).
+    #[serde(default, skip_serializing_if = "ControlWrap::is_empty")]
+    pub controls: ControlWrap,
 }
 
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize, Default)]
@@ -39,6 +50,9 @@ pub struct Table {
     /// Grid column widths, points.
     pub grid: Vec<f32>,
     pub rows: Vec<Row>,
+    /// Content controls whose content starts or ends with this table (see [`crate::control`]).
+    #[serde(default, skip_serializing_if = "ControlWrap::is_empty")]
+    pub controls: ControlWrap,
 }
 
 /// Hard limits that keep hostile input from exhausting memory.
@@ -64,8 +78,10 @@ impl Table {
                             c
                         })
                         .collect(),
+                    controls: ControlWrap::default(),
                 })
                 .collect(),
+            controls: ControlWrap::default(),
         }
     }
 
@@ -97,7 +113,7 @@ impl Table {
         if self.rows.len() >= MAX_ROWS {
             return;
         }
-        let mut row = Row { props: src.props.clone(), cells: Vec::with_capacity(src.cells.len()) };
+        let mut row = Row { props: src.props.clone(), cells: Vec::with_capacity(src.cells.len()), controls: ControlWrap::default() };
         row.props.header = false;
         for c in &src.cells {
             let mut nc = Cell::empty();
@@ -240,46 +256,111 @@ impl Table {
         }
     }
 
-    /// Split cell `c` of row `r` into `n` cells horizontally.
+    /// Split cell `c` of row `r` into `n` cells horizontally. When the cell spans fewer grid
+    /// columns than that, the grid is refined inside the cell only: the new borders divide it
+    /// into equal parts, and the cells of other rows widen over the new grid columns, so their
+    /// extent and the table's width stay as they were.
     pub fn split_cell(&mut self, r: usize, c: usize, n: usize) {
         let n = n.clamp(1, MAX_COLS);
-        let Some(row) = self.rows.get_mut(r) else { return };
-        let Some(cell) = row.cells.get_mut(c) else { return };
-        let span = cell.span();
+        let Some(span) = self.rows.get(r).and_then(|row| row.cells.get(c)).map(Cell::span) else { return };
         if n <= 1 {
             return;
         }
-        let w = cell.props.width.map(|w| w / n as f32);
-        cell.props.width = w;
         if span >= n {
+            let Some(row) = self.rows.get_mut(r) else { return };
+            let Some(cell) = row.cells.get_mut(c) else { return };
+            let w = cell.props.width.map(|w| w / n as f32);
+            cell.props.width = w;
             cell.props.span = (span - (n - 1)) as u32;
             for k in 1..n {
                 let mut nc = Cell::empty();
                 nc.props.width = w;
                 row.cells.insert(c + k, nc);
             }
-        } else {
-            // Need more grid columns: widen the grid at this column for every other row.
-            let g = self.grid_col(r, c);
-            let extra = n - span;
-            for _ in 0..extra {
-                self.insert_col(g + span);
+            return;
+        }
+        let g = self.grid_col(r, c);
+        let mut end = g.saturating_add(span);
+        // A grid narrower than the row (a damaged file) gets the columns the cell needs.
+        while self.grid.len() < end && self.grid.len() < MAX_COLS {
+            self.grid.push(72.0);
+        }
+        if self.grid.len() < end {
+            return;
+        }
+        for w in self.grid.get_mut(g..end).into_iter().flatten() {
+            if !(w.is_finite() && *w > 0.0) {
+                *w = 72.0;
             }
-            // After insert_col this row got empty cells inserted (or the cell widened): normalise
-            // the target row to n cells spanning one column each.
-            if let Some(row) = self.rows.get_mut(r) {
-                let mut x = 0;
-                for cell in row.cells.iter_mut() {
-                    if x == g {
-                        cell.props.span = 1;
+        }
+        const EPS: f32 = 0.01;
+        let total: f32 = self.grid.get(g..end).map(|x| x.iter().sum()).unwrap_or(0.0);
+        // Grid lines where the cell's parts start (after the first, at `g`).
+        let mut lines = Vec::with_capacity(n);
+        for k in 1..n {
+            let x = total * k as f32 / n as f32;
+            let mut acc = 0.0;
+            let mut hit = None;
+            for j in g..end {
+                let w = self.grid.get(j).copied().unwrap_or(0.0);
+                if j > g && (x - acc).abs() <= EPS {
+                    hit = Some((j, None));
+                    break;
+                }
+                if x < acc + w - EPS {
+                    if x > acc + EPS {
+                        hit = Some((j, Some((x - acc, w - (x - acc)))));
                     }
-                    x += cell.span();
+                    break;
                 }
-                let have: usize = row.cells.iter().map(Cell::span).sum();
-                let want = self.grid.len();
-                for _ in have..want {
-                    row.cells.insert((c + 1).min(row.cells.len()), Cell::empty());
+                acc += w;
+            }
+            match hit {
+                // An existing grid line is where the border goes.
+                Some((j, None)) => lines.push(j),
+                // A new grid line inside column `j`: every cell over `j` widens over both halves.
+                Some((j, Some((left, right)))) if self.grid.len() < MAX_COLS => {
+                    if let Some(w) = self.grid.get_mut(j) {
+                        *w = left;
+                    }
+                    self.grid.insert(j + 1, right);
+                    for rr in 0..self.rows.len() {
+                        if let Some(ci) = self.cell_at_grid(rr, j)
+                            && let Some(cell) = self.rows.get_mut(rr).and_then(|row| row.cells.get_mut(ci))
+                        {
+                            cell.props.span = cell.props.span.max(1).saturating_add(1);
+                        }
+                    }
+                    end += 1;
+                    lines.push(j + 1);
                 }
+                _ => {}
+            }
+        }
+        lines.dedup();
+        // The cell now spans `g..end`: cut it at the new lines.
+        let grid = self.grid.clone();
+        let width = |a: usize, b: usize| grid.get(a..b).map(|x| x.iter().sum::<f32>());
+        let Some(row) = self.rows.get_mut(r) else { return };
+        let mut a = g;
+        let mut parts = Vec::with_capacity(lines.len() + 1);
+        for &b in lines.iter().chain(std::iter::once(&end)) {
+            if b > a {
+                parts.push((a, b));
+                a = b;
+            }
+        }
+        for (k, &(a, b)) in parts.iter().enumerate() {
+            if k == 0 {
+                if let Some(cell) = row.cells.get_mut(c) {
+                    cell.props.span = (b - a) as u32;
+                    cell.props.width = width(a, b);
+                }
+            } else {
+                let mut nc = Cell::empty();
+                nc.props.span = (b - a) as u32;
+                nc.props.width = width(a, b);
+                row.cells.insert((c + k).min(row.cells.len()), nc);
             }
         }
     }
diff --git a/crates/doc/src/tests.rs b/crates/doc/src/tests.rs
index 559ed0b2fe..2041a4e40b 100644
--- a/crates/doc/src/tests.rs
+++ b/crates/doc/src/tests.rs
@@ -90,6 +90,7 @@ fn text_box_anchor_finds_the_owning_shape() {
         story,
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     // A plain shape before it doesn't count.
     d.insert_object(&Pos::body(0, 0), shape(None), &CharProps::default()).unwrap();
@@ -112,6 +113,7 @@ fn word_count_including_notes_counts_used_boxes_and_notes_only() {
         story: Some(story),
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     let para_of = |t: &str| vec![para_block(Paragraph::with_text(t, CharProps::default()))];
     let boxed = d.add_part(PartKind::TextBox, para_of("three four"));
@@ -152,6 +154,7 @@ fn counted_stories_survive_self_nested_boxes() {
         story: Some(id),
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     d.insert_object(&Pos::body(0, 0), shape.clone(), &CharProps::default()).unwrap();
     d.insert_object(&Pos { story: StoryRef::Part(id), path: Path::top(0), off: 0 }, shape, &CharProps::default()).unwrap();
@@ -171,6 +174,7 @@ fn prune_text_boxes_drops_only_unshown_ones() {
         story: Some(story),
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     let para_of = |t: &str| vec![para_block(Paragraph::with_text(t, CharProps::default()))];
     let mut d = Document::from_text("body");
@@ -205,6 +209,7 @@ fn notes_in_text_box_follow_nested_boxes_once() {
         story: Some(story),
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     let note = |id| InlineObject::NoteRef { kind: para::NoteKind::Footnote, id, custom: String::new() };
     let mut d = Document::new();
diff --git a/crates/doc/src/wordart.rs b/crates/doc/src/wordart.rs
new file mode 100644
index 0000000000..ace26743c6
--- /dev/null
+++ b/crates/doc/src/wordart.rs
@@ -0,0 +1,372 @@
+//! WordArt: text effects on runs and text warps on shapes.
+//!
+//! Text effects are the run properties of [MS-DOCX] §2.6 (`w14:textFill`, `w14:textOutline`,
+//! `w14:shadow`, `w14:glow`, `w14:reflection`): how a run's letters are filled and outlined and
+//! what is drawn around them. A warp ("Transform", DrawingML `a:prstTxWarp`, ECMA-376
+//! §20.1.9.19) bends a shape's whole text along a preset geometry. Lengths are points, angles
+//! degrees, transparencies percent (0 = opaque).
+
+use serde::{Deserialize, Serialize};
+
+use crate::effects::{Glow, Shadow};
+use crate::props::Rgb;
+
+/// Most gradient stops kept.
+pub const MAX_STOPS: usize = 10;
+/// Widest text outline, points.
+pub const MAX_OUTLINE: f32 = 20.0;
+/// Largest reflection gap, points.
+pub const MAX_REFLECTION_GAP: f32 = 100.0;
+/// Most adjust values a warp keeps.
+pub const MAX_ADJ: usize = 8;
+/// Largest adjust value magnitude (DrawingML angles are 60000ths of a degree, fractions 100000ths).
+pub const MAX_ADJ_VALUE: i64 = 100_000_000;
+
+/// The WordArt effects of a run. `None` fields draw the text normally (its colour, no outline).
+#[derive(Clone, Debug, PartialEq, Default, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct TextEffects {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub fill: Option<TextFill>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub outline: Option<TextOutline>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub shadow: Option<Shadow>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub glow: Option<Glow>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub reflection: Option<Reflection>,
+}
+
+/// How letters are filled.
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "camelCase")]
+pub enum TextFill {
+    /// Not filled (hollow letters: only their outline shows).
+    None,
+    Solid {
+        color: Rgb,
+        #[serde(default)]
+        transparency: f32,
+    },
+    /// A linear gradient across the run's letters, at `angle` degrees (0 = left to right, 90 = top
+    /// to bottom).
+    Gradient {
+        stops: Vec<GradStop>,
+        #[serde(default)]
+        angle: f32,
+    },
+}
+
+/// A gradient stop at `pos` percent along the gradient.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GradStop {
+    pub pos: f32,
+    pub color: Rgb,
+    #[serde(default)]
+    pub transparency: f32,
+}
+
+/// The line around letters. `color: None` is explicitly no line.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct TextOutline {
+    pub color: Option<Rgb>,
+    pub width: f32,
+    pub transparency: f32,
+}
+
+impl Default for TextOutline {
+    fn default() -> Self {
+        TextOutline { color: Some(Rgb::BLACK), width: 0.75, transparency: 0.0 }
+    }
+}
+
+/// A mirror image of the letters below them that fades out: it starts at `transparency` and
+/// fades to nothing over `size` percent of the letters' height, `distance` points below them.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct Reflection {
+    pub transparency: f32,
+    pub size: f32,
+    pub distance: f32,
+    pub blur: f32,
+}
+
+impl Default for Reflection {
+    fn default() -> Self {
+        Reflection { transparency: 50.0, size: 50.0, distance: 0.0, blur: 0.5 }
+    }
+}
+
+fn clamp(v: f32, lo: f32, hi: f32, dflt: f32) -> f32 {
+    if v.is_finite() { v.clamp(lo, hi) } else { dflt }
+}
+
+impl TextFill {
+    /// Finite, in range: at most [`MAX_STOPS`] stops, in order; a gradient without stops is no
+    /// gradient (`None` back).
+    pub fn sanitized(&self) -> Option<TextFill> {
+        Some(match self {
+            TextFill::None => TextFill::None,
+            TextFill::Solid { color, transparency } => TextFill::Solid { color: *color, transparency: clamp(*transparency, 0.0, 100.0, 0.0) },
+            TextFill::Gradient { stops, angle } => {
+                let mut s: Vec<GradStop> = stops
+                    .iter()
+                    .take(MAX_STOPS)
+                    .map(|g| GradStop { pos: clamp(g.pos, 0.0, 100.0, 0.0), color: g.color, transparency: clamp(g.transparency, 0.0, 100.0, 0.0) })
+                    .collect();
+                if s.is_empty() {
+                    return None;
+                }
+                s.sort_by(|a, b| a.pos.total_cmp(&b.pos));
+                TextFill::Gradient { stops: s, angle: clamp(*angle, -1e6, 1e6, 0.0).rem_euclid(360.0) }
+            }
+        })
+    }
+    /// One colour standing for the fill (a gradient's middle stop): what plain text, the caret
+    /// and exports without gradients use.
+    pub fn main_color(&self) -> Option<Rgb> {
+        match self {
+            TextFill::None => None,
+            TextFill::Solid { color, .. } => Some(*color),
+            TextFill::Gradient { stops, .. } => stops.get(stops.len() / 2).map(|s| s.color),
+        }
+    }
+}
+
+impl TextEffects {
+    pub fn is_empty(&self) -> bool {
+        *self == TextEffects::default()
+    }
+    /// Finite, in range; zero-size glows dropped.
+    pub fn sanitized(&self) -> TextEffects {
+        TextEffects {
+            fill: self.fill.as_ref().and_then(TextFill::sanitized),
+            outline: self.outline.map(|o| TextOutline {
+                color: o.color,
+                width: clamp(o.width, 0.0, MAX_OUTLINE, 0.75),
+                transparency: clamp(o.transparency, 0.0, 100.0, 0.0),
+            }),
+            shadow: self.shadow.map(Shadow::sanitized),
+            glow: self.glow.map(Glow::sanitized).filter(|g| g.size > 0.0),
+            reflection: self.reflection.map(|r| Reflection {
+                transparency: clamp(r.transparency, 0.0, 100.0, 50.0),
+                size: clamp(r.size, 0.0, 100.0, 50.0),
+                distance: clamp(r.distance, 0.0, MAX_REFLECTION_GAP, 0.0),
+                blur: clamp(r.blur, 0.0, crate::effects::MAX_BLUR, 0.0),
+            }),
+        }
+    }
+    /// Apply every `Some` field of `patch` on top of `self` (style, then direct formatting).
+    pub fn overlay(&mut self, patch: &TextEffects) {
+        if patch.fill.is_some() {
+            self.fill.clone_from(&patch.fill);
+        }
+        if patch.outline.is_some() {
+            self.outline = patch.outline;
+        }
+        if patch.shadow.is_some() {
+            self.shadow = patch.shadow;
+        }
+        if patch.glow.is_some() {
+            self.glow = patch.glow;
+        }
+        if patch.reflection.is_some() {
+            self.reflection = patch.reflection;
+        }
+    }
+}
+
+/// Our WordArt styles (Shape Format › WordArt Styles, Insert › WordArt): id and label. Their
+/// colours come from the document's theme ([`art_style`]).
+pub const ART_STYLES: [(&str, &str); 8] = [
+    ("solid", "Solid Accent"),
+    ("outlined", "Light with Outline"),
+    ("hollow", "Hollow"),
+    ("gradient", "Accent Gradient"),
+    ("shadowed", "Dark with Shadow"),
+    ("glowing", "Soft Glow"),
+    ("reflected", "Accent with Reflection"),
+    ("sunset", "Warm Gradient with Outline"),
+];
+
+/// The text effects of WordArt style `id` (see [`ART_STYLES`]) in theme colours `theme` (dk1,
+/// lt1, dk2, lt2, accent1…6 as in [`crate::THEME_COLORS`]). `None` for an unknown id.
+pub fn art_style(id: &str, theme: &[Rgb]) -> Option<TextEffects> {
+    let slot = |i: usize| theme.get(i).or_else(|| crate::THEME_COLORS.get(i)).copied().unwrap_or(Rgb::BLACK);
+    let (dark, light, accent, accent2) = (slot(2), slot(1), slot(4), slot(5));
+    let solid = |c: Rgb| Some(TextFill::Solid { color: c, transparency: 0.0 });
+    let line = |c: Rgb, w: f32| Some(TextOutline { color: Some(c), width: w, transparency: 0.0 });
+    let grad = |a: Rgb, b: Rgb| {
+        Some(TextFill::Gradient {
+            stops: vec![GradStop { pos: 0.0, color: a, transparency: 0.0 }, GradStop { pos: 100.0, color: b, transparency: 0.0 }],
+            angle: 90.0,
+        })
+    };
+    let fx = match id {
+        "solid" => TextEffects { fill: solid(accent), ..Default::default() },
+        "outlined" => TextEffects { fill: solid(light), outline: line(accent, 1.0), ..Default::default() },
+        "hollow" => TextEffects { fill: Some(TextFill::None), outline: line(dark, 1.0), ..Default::default() },
+        "gradient" => TextEffects { fill: grad(accent, slot(7)), ..Default::default() },
+        "shadowed" => TextEffects {
+            fill: solid(dark),
+            shadow: Some(Shadow { color: Rgb::BLACK, transparency: 55.0, blur: 3.0, distance: 3.0, angle: 45.0, rot_with_shape: false }),
+            ..Default::default()
+        },
+        "glowing" => TextEffects {
+            fill: solid(light),
+            outline: line(accent, 0.5),
+            glow: Some(Glow { color: accent, size: 6.0, transparency: 55.0 }),
+            ..Default::default()
+        },
+        "reflected" => TextEffects { fill: solid(accent), reflection: Some(Reflection::default()), ..Default::default() },
+        "sunset" => TextEffects { fill: grad(accent2, slot(8)), outline: line(dark, 0.5), ..Default::default() },
+        _ => return None,
+    };
+    Some(fx)
+}
+
+/// Every DrawingML preset text warp (ECMA-376 §20.1.10.76 `ST_TextShapeType`). A warp read with
+/// another name is dropped.
+pub const WARP_PRESETS: [&str; 41] = [
+    "textNoShape",
+    "textPlain",
+    "textStop",
+    "textTriangle",
+    "textTriangleInverted",
+    "textChevron",
+    "textChevronInverted",
+    "textRingInside",
+    "textRingOutside",
+    "textArchUp",
+    "textArchDown",
+    "textCircle",
+    "textButton",
+    "textArchUpPour",
+    "textArchDownPour",
+    "textCirclePour",
+    "textButtonPour",
+    "textCurveUp",
+    "textCurveDown",
+    "textCanUp",
+    "textCanDown",
+    "textWave1",
+    "textWave2",
+    "textDoubleWave1",
+    "textWave4",
+    "textInflate",
+    "textDeflate",
+    "textInflateBottom",
+    "textDeflateBottom",
+    "textInflateTop",
+    "textDeflateTop",
+    "textDeflateInflate",
+    "textDeflateInflateDeflate",
+    "textFadeRight",
+    "textFadeLeft",
+    "textFadeUp",
+    "textFadeDown",
+    "textSlantUp",
+    "textSlantDown",
+    "textCascadeUp",
+    "textCascadeDown",
+];
+
+/// The warps WordCraft draws bent (the others round-trip and draw flat), with menu labels.
+pub const DRAWN_WARPS: [(&str, &str); 12] = [
+    ("textArchUp", "Arch Up"),
+    ("textArchDown", "Arch Down"),
+    ("textCircle", "Circle"),
+    ("textWave1", "Wave"),
+    ("textSlantUp", "Slant Up"),
+    ("textSlantDown", "Slant Down"),
+    ("textInflate", "Inflate"),
+    ("textDeflate", "Deflate"),
+    ("textChevron", "Chevron Up"),
+    ("textChevronInverted", "Chevron Down"),
+    ("textTriangle", "Triangle Up"),
+    ("textTriangleInverted", "Triangle Down"),
+];
+
+/// A shape's text warp: a preset and its adjust values (`a:avLst/a:gd`, name and `val`).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TextWarp {
+    pub preset: String,
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub adj: Vec<(String, i64)>,
+}
+
+impl TextWarp {
+    /// A warp with preset `preset` (one of [`WARP_PRESETS`]); `None` for any other name.
+    pub fn new(preset: &str) -> Option<TextWarp> {
+        WARP_PRESETS.iter().find(|p| **p == preset).map(|p| TextWarp { preset: (*p).to_string(), adj: Vec::new() })
+    }
+    /// Add an adjust value (capped: at most [`MAX_ADJ`], short ASCII names, values within
+    /// ±[`MAX_ADJ_VALUE`]); a repeated name replaces the earlier value.
+    pub fn set_adj(&mut self, name: &str, val: i64) {
+        if name.is_empty() || name.len() > 16 || !name.chars().all(|c| c.is_ascii_alphanumeric()) {
+            return;
+        }
+        let val = val.clamp(-MAX_ADJ_VALUE, MAX_ADJ_VALUE);
+        if let Some(slot) = self.adj.iter_mut().find(|(n, _)| n == name) {
+            slot.1 = val;
+        } else if self.adj.len() < MAX_ADJ {
+            self.adj.push((name.to_string(), val));
+        }
+    }
+    /// The adjust value `name`, if set.
+    pub fn adj_value(&self, name: &str) -> Option<i64> {
+        self.adj.iter().find(|(n, _)| n == name).map(|(_, v)| *v)
+    }
+    /// Valid: a known preset, capped adjust values (what files and commands are reduced to).
+    pub fn sanitized(&self) -> Option<TextWarp> {
+        let mut w = TextWarp::new(&self.preset)?;
+        for (n, v) in &self.adj {
+            w.set_adj(n, *v);
+        }
+        Some(w)
+    }
+    /// Does the warp leave the text as it is (`textNoShape`, `textPlain`)?
+    pub fn is_plain(&self) -> bool {
+        matches!(self.preset.as_str(), "textNoShape" | "textPlain")
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn hostile_values_are_reduced() {
+        let fx = TextEffects {
+            fill: Some(TextFill::Gradient {
+                stops: (0..50).map(|i| GradStop { pos: if i == 0 { f32::NAN } else { 1e9 }, color: Rgb::BLACK, transparency: -5.0 }).collect(),
+                angle: f32::INFINITY,
+            }),
+            outline: Some(TextOutline { color: None, width: 1e9, transparency: f32::NAN }),
+            ..Default::default()
+        }
+        .sanitized();
+        let Some(TextFill::Gradient { stops, angle }) = fx.fill else { panic!("a gradient") };
+        assert_eq!(stops.len(), MAX_STOPS);
+        assert!(stops.iter().all(|s| (0.0..=100.0).contains(&s.pos) && s.transparency == 0.0));
+        assert_eq!(angle, 0.0);
+        assert_eq!(fx.outline.map(|o| o.width), Some(MAX_OUTLINE));
+        assert_eq!(TextFill::Gradient { stops: vec![], angle: 0.0 }.sanitized(), None);
+
+        assert!(TextWarp::new("textMadeUp").is_none());
+        let mut w = TextWarp::new("textArchUp").unwrap();
+        for i in 0..20 {
+            w.set_adj(&format!("adj{i}"), i64::MAX);
+        }
+        w.set_adj("bad name!", 1);
+        assert_eq!(w.adj.len(), MAX_ADJ);
+        assert!(w.adj.iter().all(|(_, v)| *v == MAX_ADJ_VALUE));
+        for (id, _) in ART_STYLES {
+            assert!(art_style(id, &[]).is_some(), "{id}");
+        }
+    }
+}
diff --git a/crates/doc/src/wrap.rs b/crates/doc/src/wrap.rs
index d4abb74cfe..5b4f5ae096 100644
--- a/crates/doc/src/wrap.rs
+++ b/crates/doc/src/wrap.rs
@@ -66,7 +66,13 @@ pub fn shape_outline(kind: ShapeKind, w: f32, h: f32) -> Option<Vec<(f32, f32)>>
     let (w, h) = (pos(w), pos(h));
     let pts = match kind {
         // A freeform's paths (ink among them) aren't known from its kind: its frame is its outline.
-        ShapeKind::Rectangle | ShapeKind::TextBox | ShapeKind::Line | ShapeKind::Freeform => return None,
+        ShapeKind::Rectangle
+        | ShapeKind::TextBox
+        | ShapeKind::Line
+        | ShapeKind::Freeform
+        | ShapeKind::StraightConnector
+        | ShapeKind::ElbowConnector
+        | ShapeKind::CurvedConnector => return None,
         ShapeKind::Ellipse => (0..48).map(|i| (i as f32) * TAU / 48.0).map(|a| (0.5 + 0.5 * a.cos(), 0.5 + 0.5 * a.sin())).collect(),
         ShapeKind::RoundedRectangle => {
             // Corner radius as drawn: 16% of the shorter side.
diff --git a/crates/docbin/src/fmt.rs b/crates/docbin/src/fmt.rs
index 446a57d496..30b830115e 100644
--- a/crates/docbin/src/fmt.rs
+++ b/crates/docbin/src/fmt.rs
@@ -30,6 +30,11 @@ const P_DXA_LEFT80: u16 = 0x840F;
 const P_DXA_RIGHT: u16 = 0x845D;
 const P_DXA_RIGHT80: u16 = 0x840E;
 const P_DXA_FIRST: u16 = 0x8460; // sprmPDxaLeft1
+const P_DXA_FIRST80: u16 = 0x8411; // sprmPDxaLeft1_80
+// Indents in hundredths of a character (sprmPDxcRight, sprmPDxcLeft, sprmPDxcLeft1).
+const P_DXC_RIGHT: u16 = 0x4455;
+const P_DXC_LEFT: u16 = 0x4456;
+const P_DXC_FIRST: u16 = 0x4457;
 const P_DYA_BEFORE: u16 = 0xA413;
 const P_DYA_AFTER: u16 = 0xA414;
 const P_DYA_LINE: u16 = 0x6412;
@@ -186,12 +191,6 @@ pub(crate) fn apply_char(p: &mut CharProps, prl: &Prl, base: &CharProps, fonts:
 pub(crate) fn apply_para(p: &mut ParaProps, prl: &Prl) {
     let tw = |v: i32| (v as f32 / 20.0).clamp(-1000.0, 1000.0);
     let s16 = |prl: &Prl| -> Option<i16> { u16_of(prl).map(|v| v as i16) };
-    let i32of = |prl: &Prl| -> Option<i32> {
-        match prl.operand {
-            [b0, b1, b2, b3, ..] => Some(i32::from_le_bytes([*b0, *b1, *b2, *b3])),
-            _ => None,
-        }
-    };
     match prl.op {
         P_JC | P_JC80 => {
             p.align = match prl.operand.first().copied().unwrap_or(0) {
@@ -212,9 +211,20 @@ pub(crate) fn apply_para(p: &mut ParaProps, prl: &Prl) {
                 p.indent_right = Some(tw(v as i32));
             }
         }
-        P_DXA_FIRST => {
-            if let Some(v) = i32of(prl) {
-                p.indent_first = Some(tw(v));
+        // A two-byte operand, like the other indents (spra 4).
+        P_DXA_FIRST | P_DXA_FIRST80 => {
+            if let Some(v) = s16(prl) {
+                p.indent_first = Some(tw(v as i32));
+            }
+        }
+        P_DXC_RIGHT | P_DXC_LEFT | P_DXC_FIRST => {
+            if let Some(v) = s16(prl) {
+                let chars = Some(f32::from(v) / 100.0);
+                match prl.op {
+                    P_DXC_RIGHT => p.indent_right_chars = chars,
+                    P_DXC_LEFT => p.indent_left_chars = chars,
+                    _ => p.indent_first_chars = chars,
+                }
             }
         }
         P_DYA_BEFORE => {
@@ -227,13 +237,18 @@ pub(crate) fn apply_para(p: &mut ParaProps, prl: &Prl) {
                 p.space_after = Some((v as f32 / 20.0).clamp(0.0, 3168.0));
             }
         }
+        // LSPD ([MS-DOC] §2.9.150): a signed dyaLine, then fMultLinespace. In lines (240ths) when
+        // fMultLinespace is 1; else twips, at least when positive and exactly when negative.
         P_DYA_LINE => {
-            if let Some(v) = u16_of(prl) {
-                let mult = (v & 0x3FFF) as f32;
-                p.line_spacing = Some(match v & 0xC000 {
-                    0x0000 => LineSpacing::Multiple((mult / 240.0).clamp(0.1, 20.0)),
-                    0x8000 => LineSpacing::AtLeast((mult / 20.0).clamp(0.0, 1584.0)),
-                    _ => LineSpacing::Exactly((mult / 20.0).clamp(0.0, 1584.0)),
+            if let Some(v) = s16(prl) {
+                let mult = prl.operand.get(2..4).is_some_and(|b| b == [1, 0]);
+                let v = f32::from(v);
+                p.line_spacing = Some(if mult {
+                    LineSpacing::Multiple((v.abs() / 240.0).clamp(0.06, 132.0))
+                } else if v < 0.0 {
+                    LineSpacing::Exactly((-v / 20.0).clamp(0.7, 1584.0))
+                } else {
+                    LineSpacing::AtLeast((v / 20.0).clamp(0.0, 1584.0))
                 });
             }
         }
diff --git a/crates/docbin/src/list.rs b/crates/docbin/src/list.rs
index 00b8da8dd2..6038821a9e 100644
--- a/crates/docbin/src/list.rs
+++ b/crates/docbin/src/list.rs
@@ -47,23 +47,29 @@ fn bullet_char(c: u16) -> char {
     }
 }
 
-/// MSONFC → model number format ([MS-OSHARED] §2.2.1.3; 0x17 = bullets, 0xFF = none).
+/// MSONFC → model number format ([MS-OSHARED] §2.2.1.3; 0x17 = bullets, 0xFF = none). Codes
+/// 0x00 to 0x27 run in the order of ST_NumberFormat (decimal, upperRoman … 0x16 decimalZero, 0x17
+/// bullet … 0x25 chineseCounting, 0x26 chineseLegalSimplified, 0x27 chineseCountingThousand);
+/// later codes are drawn as decimal.
 fn num_format(nfc: u8) -> NumFormat {
     match nfc {
-        0x01 => NumFormat::UpperRoman,
-        0x02 => NumFormat::LowerRoman,
-        0x03 => NumFormat::UpperLetter,
-        0x04 => NumFormat::LowerLetter,
-        0x05 => NumFormat::Ordinal,
-        0x06 => NumFormat::CardinalText,
-        0x07 => NumFormat::OrdinalText,
-        0x0A | 0x0B => NumFormat::DecimalZero,
-        0x17 => NumFormat::Bullet,
         0xFF => NumFormat::None,
+        0x00..=0x27 => NumFormat::ALL.get(nfc as usize).copied().unwrap_or(NumFormat::Decimal),
         _ => NumFormat::Decimal,
     }
 }
 
+#[cfg(test)]
+#[test]
+fn number_format_codes() {
+    assert_eq!(num_format(0x04), NumFormat::LowerLetter);
+    assert_eq!(num_format(0x16), NumFormat::DecimalZero);
+    assert_eq!(num_format(0x17), NumFormat::Bullet);
+    assert_eq!(num_format(0x25), NumFormat::ChineseCounting);
+    assert_eq!(num_format(0x27), NumFormat::ChineseCountingThousand);
+    assert_eq!(num_format(0x60), NumFormat::Decimal);
+}
+
 /// Read the lists of a document; empty when the FIB carries none (or they are unreadable).
 pub(crate) fn parse(table: &[u8], fib: &Fib, fonts: &[String]) -> Numbering {
     let defs = match fib.pair(pair::PLF_LST) {
diff --git a/crates/docbin/src/table.rs b/crates/docbin/src/table.rs
index 22c2462a80..e341618626 100644
--- a/crates/docbin/src/table.rs
+++ b/crates/docbin/src/table.rs
@@ -209,7 +209,7 @@ pub(crate) fn assemble(paras: Vec<ParaOut>) -> Blocks {
         if blocks.is_empty() {
             blocks.push(para_block(Paragraph::new()));
         }
-        cells.push(Cell { props: CellProps { span: 1, ..Default::default() }, blocks });
+        cells.push(Cell { props: CellProps { span: 1, ..Default::default() }, blocks, controls: Default::default() });
     }
     fn build_row(mut cells: Vec<Cell>, info: &RowInfo) -> Row {
         // Per-cell overrides first (sprm cell indices count pre-merge cells), then merges.
@@ -253,6 +253,7 @@ pub(crate) fn assemble(paras: Vec<ParaOut>) -> Blocks {
                 fmt_change: None,
             },
             cells,
+            controls: Default::default(),
         }
     }
     fn flush_table(out: &mut Blocks, rows: &mut Vec<Row>, cells: &mut Vec<Cell>, cell: &mut Blocks, grid: &[f32], props: &TableProps, nested: bool) {
@@ -278,7 +279,12 @@ pub(crate) fn assemble(paras: Vec<ParaOut>) -> Blocks {
                 }
             }
         } else {
-            out.push(Arc::new(Block::Table(Table { props: props.clone(), grid: grid.to_vec(), rows: std::mem::take(rows) })));
+            out.push(Arc::new(Block::Table(Table {
+                props: props.clone(),
+                grid: grid.to_vec(),
+                rows: std::mem::take(rows),
+                controls: Default::default(),
+            })));
         }
         rows.clear();
     }
diff --git a/crates/docbin/src/tests.rs b/crates/docbin/src/tests.rs
index 0feb1292bf..52582193de 100644
--- a/crates/docbin/src/tests.rs
+++ b/crates/docbin/src/tests.rs
@@ -673,6 +673,34 @@ fn paragraph_props_and_heading_style() {
     assert_eq!(p1.props.style.as_deref(), Some("Normal"));
 }
 
+/// #534: Chinese theses set a first-line indent of two characters (`sprmPDxaLeft1`, whose operand
+/// is two bytes, plus `sprmPDxcLeft1` in hundredths of a character), and exact line spacing as a
+/// negative LSPD `dyaLine`. Both were lost: the indent read as four bytes, and exact 20pt as
+/// 799pt, a page per empty paragraph.
+#[test]
+fn first_line_indent_chars_and_exact_line_spacing() {
+    let lspd = |dya: i16, mult: u16| [dya.to_le_bytes(), mult.to_le_bytes()].concat();
+    let (exact, multiple) = (lspd(-400, 0), lspd(360, 1));
+    let spec = RichSpec {
+        text: "indented\rexact\rold\r",
+        styles: vec![(1, 0, "Normal", Vec::new(), Vec::new())],
+        fonts: vec!["Times New Roman"],
+        chpx_runs: vec![(0, Vec::new())],
+        papx_entries: vec![
+            (0, 0, grpprl(&[(0x8460, &480i16.to_le_bytes()), (0x4457, &200i16.to_le_bytes()), (0x6412, &multiple)])),
+            (9, 0, grpprl(&[(0x6412, &exact)])),
+            (15, 0, grpprl(&[(0x8411, &(-360i16).to_le_bytes())])),
+        ],
+    };
+    let doc = read(&rich_doc(&spec)).expect("opens");
+    let para = |i: usize| doc.body.get(i).and_then(|b| b.as_para()).expect("para").props.clone();
+    let p0 = para(0);
+    assert_eq!((p0.indent_first, p0.indent_first_chars), (Some(24.0), Some(2.0)));
+    assert_eq!(p0.line_spacing, Some(wordcraft_doc::props::LineSpacing::Multiple(1.5)));
+    assert_eq!(para(1).line_spacing, Some(wordcraft_doc::props::LineSpacing::Exactly(20.0)));
+    assert_eq!(para(2).indent_first, Some(-18.0)); // sprmPDxaLeft1_80: a hanging indent
+}
+
 /// Local corpus (gitignored `plan/word/fixtures`): real files must open with text and styles.
 #[test]
 fn corpus_files_open() {
diff --git a/crates/docx/src/chart_spec.rs b/crates/docx/src/chart_spec.rs
new file mode 100644
index 0000000000..698db44c0d
--- /dev/null
+++ b/crates/docx/src/chart_spec.rs
@@ -0,0 +1,497 @@
+//! Charts WordCraft makes ([`ChartSpec`]) as chart parts (ECMA-376 Part 1 §21.2) and back.
+//!
+//! [`chart_xml`] writes a `c:chartSpace` with the data as literals in the part itself
+//! (`c:strLit`, `c:numLit`): no embedded workbook (`c:externalData`) and no external references.
+//! [`chart_items`] draws a chart through the same code that draws chart parts read from files.
+//! [`spec_of`] turns a chart part back into the model only when writing that model again gives
+//! the same markup, so a chart with anything the model leaves out stays as it was read.
+
+use wordcraft_doc::chart::{ChartSeries, ChartSpec, ChartType, LegendPos};
+use wordcraft_doc::graphic::GraphicItem;
+use wordcraft_doc::props::Rgb;
+
+use crate::xml::{self, El, MAX_DEPTH, Node, W};
+
+const NS_C: &str = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+const NS_A: &str = "http://schemas.openxmlformats.org/drawingml/2006/main";
+const NS_R: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+/// Content type of a chart part.
+pub(crate) const CHART_CT: &str = "application/vnd.openxmlformats-officedocument.drawingml.chart+xml";
+/// `a:graphicData` URI of a chart.
+pub(crate) const CHART_URI: &str = "http://schemas.openxmlformats.org/drawingml/2006/chart";
+/// Axis ids (any pair of distinct numbers will do; Word keeps them).
+const CAT_AX: &str = "500000001";
+const VAL_AX: &str = "500000002";
+
+/// The chart part for `spec`: a complete XML document. `spec` should be sanitized
+/// ([`ChartSpec::sanitize`]); a value that isn't finite is written as a gap either way.
+pub fn chart_xml(spec: &ChartSpec) -> String {
+    let mut w = W::new();
+    w.open("c:chartSpace", &[("xmlns:c", NS_C), ("xmlns:a", NS_A), ("xmlns:r", NS_R)]);
+    w.empty("c:roundedCorners", &[("val", "0")]);
+    w.open("c:chart", &[]);
+    if let Some(t) = &spec.title {
+        w.open("c:title", &[]);
+        w.open("c:tx", &[]);
+        w.open("c:rich", &[]);
+        w.empty("a:bodyPr", &[]);
+        w.empty("a:lstStyle", &[]);
+        w.open("a:p", &[]);
+        w.open("a:r", &[]);
+        w.leaf("a:t", &[], t);
+        w.close("a:r");
+        w.close("a:p");
+        w.close("c:rich");
+        w.close("c:tx");
+        w.empty("c:overlay", &[("val", "0")]);
+        w.close("c:title");
+    }
+    w.empty("c:autoTitleDeleted", &[("val", if spec.title.is_some() { "0" } else { "1" })]);
+    w.open("c:plotArea", &[]);
+    w.empty("c:layout", &[]);
+    plot(&mut w, spec);
+    w.close("c:plotArea");
+    if let Some(pos) = spec.legend {
+        w.open("c:legend", &[]);
+        let p = match pos {
+            LegendPos::Right => "r",
+            LegendPos::Left => "l",
+            LegendPos::Top => "t",
+            LegendPos::Bottom => "b",
+        };
+        w.empty("c:legendPos", &[("val", p)]);
+        w.empty("c:overlay", &[("val", "0")]);
+        w.close("c:legend");
+    }
+    w.empty("c:plotVisOnly", &[("val", "1")]);
+    w.empty("c:dispBlanksAs", &[("val", "gap")]);
+    w.close("c:chart");
+    // A white chart area without a border, in the document's own background colour.
+    w.open("c:spPr", &[]);
+    w.open("a:solidFill", &[]);
+    w.empty("a:schemeClr", &[("val", "bg1")]);
+    w.close("a:solidFill");
+    w.open("a:ln", &[]);
+    w.empty("a:noFill", &[]);
+    w.close("a:ln");
+    w.close("c:spPr");
+    w.close("c:chartSpace");
+    w.s
+}
+
+/// What `spec` draws as, `w` × `h` points, in the colours of `theme` (series take the accents in
+/// turn). Empty when the chart has no series.
+pub fn chart_items(spec: &ChartSpec, theme: &[Rgb], w: f32, h: f32) -> Vec<GraphicItem> {
+    match xml::parse(chart_xml(spec).as_bytes()) {
+        Ok(space) => crate::read::chart::chart_items(&space, theme, w, h),
+        Err(_) => Vec::new(),
+    }
+}
+
+/// The chart type element and the series in it, then the axes.
+fn plot(w: &mut W, spec: &ChartSpec) {
+    let k = spec.kind;
+    let el = match k {
+        ChartType::Column | ChartType::ColumnStacked | ChartType::Bar | ChartType::BarStacked => "c:barChart",
+        ChartType::Line => "c:lineChart",
+        ChartType::Area => "c:areaChart",
+        ChartType::Pie => "c:pieChart",
+        ChartType::Doughnut => "c:doughnutChart",
+        ChartType::Scatter => "c:scatterChart",
+    };
+    let stacked = matches!(k, ChartType::ColumnStacked | ChartType::BarStacked);
+    let horizontal = matches!(k, ChartType::Bar | ChartType::BarStacked);
+    w.open(el, &[]);
+    match k {
+        ChartType::Column | ChartType::ColumnStacked | ChartType::Bar | ChartType::BarStacked => {
+            w.empty("c:barDir", &[("val", if horizontal { "bar" } else { "col" })]);
+            w.empty("c:grouping", &[("val", if stacked { "stacked" } else { "clustered" })]);
+        }
+        ChartType::Line | ChartType::Area => w.empty("c:grouping", &[("val", "standard")]),
+        ChartType::Scatter => w.empty("c:scatterStyle", &[("val", "lineMarker")]),
+        ChartType::Pie | ChartType::Doughnut => {}
+    }
+    w.empty("c:varyColors", &[("val", if k.is_round() { "1" } else { "0" })]);
+    // Pie and doughnut charts show the first series; the others are kept for other types.
+    for (i, s) in spec.series.iter().enumerate() {
+        series(w, spec, i, s);
+    }
+    if spec.data_labels {
+        w.open("c:dLbls", &[]);
+        for (name, on) in [
+            ("c:showLegendKey", false),
+            ("c:showVal", true),
+            ("c:showCatName", false),
+            ("c:showSerName", false),
+            ("c:showPercent", false),
+            ("c:showBubbleSize", false),
+        ] {
+            w.empty(name, &[("val", if on { "1" } else { "0" })]);
+        }
+        w.close("c:dLbls");
+    }
+    match k {
+        ChartType::Column | ChartType::ColumnStacked | ChartType::Bar | ChartType::BarStacked => {
+            w.empty("c:gapWidth", &[("val", "150")]);
+            if stacked {
+                w.empty("c:overlap", &[("val", "100")]);
+            }
+        }
+        ChartType::Line => w.empty("c:marker", &[("val", "1")]),
+        ChartType::Pie => w.empty("c:firstSliceAng", &[("val", "0")]),
+        ChartType::Doughnut => {
+            w.empty("c:firstSliceAng", &[("val", "0")]);
+            w.empty("c:holeSize", &[("val", "50")]);
+        }
+        ChartType::Area | ChartType::Scatter => {}
+    }
+    if !k.is_round() {
+        w.empty("c:axId", &[("val", CAT_AX)]);
+        w.empty("c:axId", &[("val", VAL_AX)]);
+    }
+    w.close(el);
+    match k {
+        ChartType::Pie | ChartType::Doughnut => {}
+        ChartType::Scatter => {
+            value_axis(w, CAT_AX, VAL_AX, "b", false, "midCat");
+            value_axis(w, VAL_AX, CAT_AX, "l", true, "midCat");
+        }
+        _ => {
+            category_axis(w, if horizontal { "l" } else { "b" });
+            value_axis(w, VAL_AX, CAT_AX, if horizontal { "b" } else { "l" }, true, "between");
+        }
+    }
+}
+
+/// One `c:ser` (ECMA-376 element order: idx, order, tx, spPr, marker, cat/xVal, val/yVal, smooth).
+fn series(w: &mut W, spec: &ChartSpec, i: usize, s: &ChartSeries) {
+    let k = spec.kind;
+    let i = i.to_string();
+    w.open("c:ser", &[]);
+    w.empty("c:idx", &[("val", &i)]);
+    w.empty("c:order", &[("val", &i)]);
+    if !s.name.is_empty() {
+        w.open("c:tx", &[]);
+        w.leaf("c:v", &[], &s.name);
+        w.close("c:tx");
+    }
+    match k {
+        // Markers only: the series has no line.
+        ChartType::Scatter => {
+            w.open("c:spPr", &[]);
+            w.open("a:ln", &[("w", "19050")]);
+            w.empty("a:noFill", &[]);
+            w.close("a:ln");
+            w.close("c:spPr");
+        }
+        ChartType::Column | ChartType::ColumnStacked | ChartType::Bar | ChartType::BarStacked => {
+            w.empty("c:invertIfNegative", &[("val", "0")]);
+        }
+        ChartType::Line => {
+            w.open("c:marker", &[]);
+            w.empty("c:symbol", &[("val", "none")]);
+            w.close("c:marker");
+        }
+        _ => {}
+    }
+    if k == ChartType::Scatter {
+        let xs: Option<Vec<Option<f64>>> = spec
+            .categories
+            .iter()
+            .map(|c| if c.is_empty() { Some(None) } else { c.parse::<f64>().ok().filter(|v| v.is_finite()).map(Some) })
+            .collect();
+        w.open("c:xVal", &[]);
+        match xs {
+            Some(xs) => num_lit(w, &xs),
+            None => str_lit(w, &spec.categories),
+        }
+        w.close("c:xVal");
+        w.open("c:yVal", &[]);
+        num_lit(w, &s.values);
+        w.close("c:yVal");
+    } else {
+        w.open("c:cat", &[]);
+        str_lit(w, &spec.categories);
+        w.close("c:cat");
+        w.open("c:val", &[]);
+        num_lit(w, &s.values);
+        w.close("c:val");
+    }
+    if matches!(k, ChartType::Line | ChartType::Scatter) {
+        w.empty("c:smooth", &[("val", "0")]);
+    }
+    w.close("c:ser");
+}
+
+fn str_lit(w: &mut W, items: &[String]) {
+    w.open("c:strLit", &[]);
+    w.empty("c:ptCount", &[("val", &items.len().to_string())]);
+    for (i, s) in items.iter().enumerate().filter(|(_, s)| !s.is_empty()) {
+        w.open("c:pt", &[("idx", &i.to_string())]);
+        w.leaf("c:v", &[], s);
+        w.close("c:pt");
+    }
+    w.close("c:strLit");
+}
+
+fn num_lit(w: &mut W, values: &[Option<f64>]) {
+    w.open("c:numLit", &[]);
+    w.leaf("c:formatCode", &[], "General");
+    w.empty("c:ptCount", &[("val", &values.len().to_string())]);
+    for (i, v) in values.iter().enumerate() {
+        if let Some(v) = v.filter(|v| v.is_finite()) {
+            w.open("c:pt", &[("idx", &i.to_string())]);
+            w.leaf("c:v", &[], &num(v));
+            w.close("c:pt");
+        }
+    }
+    w.close("c:numLit");
+}
+
+/// A value as the shortest text that reads back as the same number.
+fn num(v: f64) -> String {
+    if v == 0.0 { "0".to_string() } else { format!("{v}") }
+}
+
+fn category_axis(w: &mut W, pos: &str) {
+    w.open("c:catAx", &[]);
+    w.empty("c:axId", &[("val", CAT_AX)]);
+    w.open("c:scaling", &[]);
+    w.empty("c:orientation", &[("val", "minMax")]);
+    w.close("c:scaling");
+    w.empty("c:delete", &[("val", "0")]);
+    w.empty("c:axPos", &[("val", pos)]);
+    w.empty("c:majorTickMark", &[("val", "none")]);
+    w.empty("c:minorTickMark", &[("val", "none")]);
+    w.empty("c:tickLblPos", &[("val", "nextTo")]);
+    w.empty("c:crossAx", &[("val", VAL_AX)]);
+    w.empty("c:crosses", &[("val", "autoZero")]);
+    w.empty("c:auto", &[("val", "1")]);
+    w.empty("c:lblAlgn", &[("val", "ctr")]);
+    w.empty("c:lblOffset", &[("val", "100")]);
+    w.empty("c:noMultiLvlLbl", &[("val", "0")]);
+    w.close("c:catAx");
+}
+
+/// A value axis: with gridlines and no axis line (`grid`), else with its line and no gridlines.
+fn value_axis(w: &mut W, id: &str, cross: &str, pos: &str, grid: bool, between: &str) {
+    w.open("c:valAx", &[]);
+    w.empty("c:axId", &[("val", id)]);
+    w.open("c:scaling", &[]);
+    w.empty("c:orientation", &[("val", "minMax")]);
+    w.close("c:scaling");
+    w.empty("c:delete", &[("val", "0")]);
+    w.empty("c:axPos", &[("val", pos)]);
+    if grid {
+        w.empty("c:majorGridlines", &[]);
+    }
+    w.empty("c:majorTickMark", &[("val", "none")]);
+    w.empty("c:minorTickMark", &[("val", "none")]);
+    w.empty("c:tickLblPos", &[("val", "nextTo")]);
+    if grid {
+        w.open("c:spPr", &[]);
+        w.open("a:ln", &[]);
+        w.empty("a:noFill", &[]);
+        w.close("a:ln");
+        w.close("c:spPr");
+    }
+    w.empty("c:crossAx", &[("val", cross)]);
+    w.empty("c:crosses", &[("val", "autoZero")]);
+    w.empty("c:crossBetween", &[("val", between)]);
+    w.close("c:valAx");
+}
+
+/// The chart a chart part holds, when the part is exactly what [`chart_xml`] writes for it (so
+/// editing and saving it loses nothing). `None` for any other chart.
+pub(crate) fn spec_of(space: &El) -> Option<ChartSpec> {
+    let chart = space.child("c:chart")?;
+    let plot = chart.child("c:plotArea")?;
+    let ty = plot.els().find(|e| e.name.ends_with("Chart"))?;
+    let val = |e: &El, n: &str| e.child(n).and_then(|c| c.attr("val")).map(str::to_string);
+    let bar = |stacked_kind, clustered_kind| if val(ty, "c:grouping").as_deref() == Some("stacked") { stacked_kind } else { clustered_kind };
+    let kind = match ty.name.as_str() {
+        "c:barChart" if val(ty, "c:barDir").as_deref() == Some("bar") => bar(ChartType::BarStacked, ChartType::Bar),
+        "c:barChart" => bar(ChartType::ColumnStacked, ChartType::Column),
+        "c:lineChart" => ChartType::Line,
+        "c:areaChart" => ChartType::Area,
+        "c:pieChart" => ChartType::Pie,
+        "c:doughnutChart" => ChartType::Doughnut,
+        "c:scatterChart" => ChartType::Scatter,
+        _ => return None,
+    };
+    let scatter = kind == ChartType::Scatter;
+    let sers: Vec<&El> = ty.children("c:ser").take(wordcraft_doc::chart::MAX_SERIES + 1).collect();
+    // More than the model holds can't be the same chart: don't build it to find out.
+    let count = |s: &&El| s.find("c:ptCount").and_then(|c| c.attr("val")).and_then(|v| v.parse::<usize>().ok()).unwrap_or(0);
+    let longest = sers.iter().map(count).max().unwrap_or(0);
+    if sers.len() > wordcraft_doc::chart::MAX_SERIES
+        || longest > wordcraft_doc::chart::MAX_POINTS
+        || sers.len().saturating_mul(longest) > wordcraft_doc::chart::MAX_CELLS
+    {
+        return None;
+    }
+    let categories = sers.first().and_then(|s| s.child(if scatter { "c:xVal" } else { "c:cat" })).map(literal).unwrap_or_default();
+    let series = sers
+        .iter()
+        .map(|s| ChartSeries {
+            name: s.child("c:tx").and_then(|t| t.child("c:v")).map(|v| v.text()).unwrap_or_default(),
+            values: s
+                .child(if scatter { "c:yVal" } else { "c:val" })
+                .map(literal)
+                .unwrap_or_default()
+                .iter()
+                .map(|v| v.parse::<f64>().ok().filter(|v| v.is_finite()))
+                .collect(),
+        })
+        .collect();
+    let title = chart.child("c:title").and_then(|t| t.find("a:t")).map(|t| t.text());
+    let legend = chart.child("c:legend").map(|l| match val(l, "c:legendPos").as_deref() {
+        Some("l") => LegendPos::Left,
+        Some("t") => LegendPos::Top,
+        Some("b") => LegendPos::Bottom,
+        _ => LegendPos::Right,
+    });
+    let data_labels = ty.child("c:dLbls").and_then(|d| d.child("c:showVal")).and_then(|v| v.attr("val")) == Some("1");
+    let spec = ChartSpec { kind, categories, series, title, legend, data_labels }.sanitized();
+    // Editable only when nothing would be lost: writing the model again gives the same part.
+    let again = xml::parse(chart_xml(&spec).as_bytes()).ok()?;
+    same(space, &again, 0).then_some(spec)
+}
+
+/// The points of a `c:strLit` / `c:numLit` (or a cache) as texts by index, `ptCount` long.
+fn literal(e: &El) -> Vec<String> {
+    let Some(lit) = e.els().find(|c| matches!(c.name.as_str(), "c:strLit" | "c:numLit")) else { return Vec::new() };
+    let n = lit
+        .child("c:ptCount")
+        .and_then(|c| c.attr("val"))
+        .and_then(|v| v.parse::<usize>().ok())
+        .unwrap_or(0)
+        .min(wordcraft_doc::chart::MAX_POINTS + 1);
+    let mut out = vec![String::new(); n];
+    for p in lit.children("c:pt") {
+        if let Some(slot) = p.attr("idx").and_then(|i| i.parse::<usize>().ok()).and_then(|i| out.get_mut(i)) {
+            *slot = p.child("c:v").map(|v| v.text()).unwrap_or_default();
+        }
+    }
+    out
+}
+
+/// Whether two elements are the same markup: names, attributes (in any order), child elements in
+/// order and text (whitespace-only text between elements ignored).
+fn same(a: &El, b: &El, depth: usize) -> bool {
+    if depth > MAX_DEPTH || a.name != b.name || a.attrs.len() != b.attrs.len() {
+        return false;
+    }
+    if !a.attrs.iter().all(|(k, v)| b.attr(k) == Some(v.as_str()) && b.attrs.iter().any(|(bk, _)| bk == k)) {
+        return false;
+    }
+    let text = |e: &El| -> String {
+        e.kids
+            .iter()
+            .filter_map(|n| match n {
+                Node::Text(t) if !t.trim().is_empty() => Some(t.as_str()),
+                _ => None,
+            })
+            .collect()
+    };
+    if text(a) != text(b) {
+        return false;
+    }
+    let (mut x, mut y) = (a.els(), b.els());
+    loop {
+        match (x.next(), y.next()) {
+            (None, None) => return true,
+            (Some(p), Some(q)) if same(p, q, depth + 1) => {}
+            _ => return false,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use wordcraft_doc::THEME_COLORS;
+
+    fn parse(spec: &ChartSpec) -> El {
+        xml::parse(chart_xml(spec).as_bytes()).unwrap()
+    }
+
+    /// Children of `e` by name, in order.
+    fn names(e: &El) -> Vec<&str> {
+        e.els().map(|c| c.name.as_str()).collect()
+    }
+
+    #[test]
+    fn every_type_reads_back_as_itself() {
+        for kind in ChartType::ALL {
+            let mut spec = ChartSpec::sample(kind);
+            spec.title = Some("Sales & <costs>".into());
+            spec.data_labels = true;
+            spec.legend = Some(LegendPos::Right);
+            spec.series[0].values[1] = None;
+            spec.categories[2] = String::new();
+            let spec = spec.sanitized();
+            assert_eq!(spec_of(&parse(&spec)).as_ref(), Some(&spec), "{kind:?}");
+            assert!(!chart_items(&spec, &THEME_COLORS, 300.0, 200.0).is_empty(), "{kind:?} draws");
+        }
+        let plain = ChartSpec { legend: None, ..ChartSpec::sample(ChartType::Line) };
+        assert_eq!(spec_of(&parse(&plain)), Some(plain));
+    }
+
+    #[test]
+    fn a_chart_with_more_than_the_model_stays_read_only() {
+        let spec = ChartSpec::sample(ChartType::Column);
+        let x = chart_xml(&spec).replace("<c:roundedCorners val=\"0\"/>", "<c:roundedCorners val=\"0\"/><c:style val=\"2\"/>");
+        assert_eq!(spec_of(&xml::parse(x.as_bytes()).unwrap()), None);
+        let x = chart_xml(&spec).replace("<c:v>3.2</c:v>", "<c:v>3.20</c:v>");
+        assert_eq!(spec_of(&xml::parse(x.as_bytes()).unwrap()), None);
+    }
+
+    #[test]
+    fn elements_come_in_schema_order() {
+        let mut spec = ChartSpec::sample(ChartType::ColumnStacked);
+        spec.title = Some("T".into());
+        spec.data_labels = true;
+        let space = parse(&spec);
+        assert_eq!(names(&space), ["c:roundedCorners", "c:chart", "c:spPr"]);
+        let chart = space.child("c:chart").unwrap();
+        assert_eq!(names(chart), ["c:title", "c:autoTitleDeleted", "c:plotArea", "c:legend", "c:plotVisOnly", "c:dispBlanksAs"]);
+        let plot = chart.child("c:plotArea").unwrap();
+        assert_eq!(names(plot), ["c:layout", "c:barChart", "c:catAx", "c:valAx"]);
+        let bar = plot.child("c:barChart").unwrap();
+        assert_eq!(
+            names(bar),
+            ["c:barDir", "c:grouping", "c:varyColors", "c:ser", "c:ser", "c:ser", "c:dLbls", "c:gapWidth", "c:overlap", "c:axId", "c:axId"]
+        );
+        assert_eq!(names(bar.child("c:ser").unwrap()), ["c:idx", "c:order", "c:tx", "c:invertIfNegative", "c:cat", "c:val"]);
+        let val_ax = plot.child("c:valAx").unwrap();
+        assert_eq!(
+            names(val_ax),
+            [
+                "c:axId",
+                "c:scaling",
+                "c:delete",
+                "c:axPos",
+                "c:majorGridlines",
+                "c:majorTickMark",
+                "c:minorTickMark",
+                "c:tickLblPos",
+                "c:spPr",
+                "c:crossAx",
+                "c:crosses",
+                "c:crossBetween"
+            ]
+        );
+        let line = parse(&ChartSpec { data_labels: true, ..ChartSpec::sample(ChartType::Line) });
+        let lc = line.child("c:chart").unwrap().child("c:plotArea").unwrap().child("c:lineChart").unwrap();
+        assert_eq!(names(lc), ["c:grouping", "c:varyColors", "c:ser", "c:ser", "c:ser", "c:dLbls", "c:marker", "c:axId", "c:axId"]);
+        assert_eq!(names(lc.child("c:ser").unwrap()), ["c:idx", "c:order", "c:tx", "c:marker", "c:cat", "c:val", "c:smooth"]);
+        let sc = parse(&ChartSpec::sample(ChartType::Scatter));
+        let sc = sc.child("c:chart").unwrap().child("c:plotArea").unwrap().child("c:scatterChart").unwrap();
+        assert_eq!(names(sc.child("c:ser").unwrap()), ["c:idx", "c:order", "c:tx", "c:spPr", "c:xVal", "c:yVal", "c:smooth"]);
+        let dn = parse(&ChartSpec::sample(ChartType::Doughnut));
+        let dn = dn.child("c:chart").unwrap().child("c:plotArea").unwrap();
+        assert_eq!(names(dn), ["c:layout", "c:doughnutChart"]);
+        assert_eq!(names(dn.child("c:doughnutChart").unwrap()), ["c:varyColors", "c:ser", "c:firstSliceAng", "c:holeSize"]);
+    }
+}
diff --git a/crates/docx/src/crypt.rs b/crates/docx/src/crypt.rs
index f95a7c720d..a01545cb80 100644
--- a/crates/docx/src/crypt.rs
+++ b/crates/docx/src/crypt.rs
@@ -223,6 +223,175 @@ pub fn check_password(password: &str) -> Result<(), DocxError> {
     Ok(())
 }
 
+/// Restrict Editing's password (`w:documentProtection`, ECMA-376 Part 1 §17.15.1.29): the
+/// attributes that store its hash — SHA-512 of a random 16-byte salt and the password as UTF-16LE,
+/// hashed again `spin_count` times with the iteration number appended ([MS-OFFCRYPTO] §2.4.2.4,
+/// the ISO write-protection method). Protection isn't encryption: the document stays readable,
+/// the password only guards turning protection off.
+pub fn protection_hash(password: &str, spin_count: u32) -> Result<Vec<(String, String)>, DocxError> {
+    check_password(password)?;
+    let spin_count = spin_count.min(MAX_SPIN_COUNT);
+    let salt = random(SALT)?;
+    let hash = iterate_appended(Hash::Sha512, &salt, password, spin_count);
+    let b64 = |b: &[u8]| base64::engine::general_purpose::STANDARD.encode(b);
+    Ok(vec![
+        ("w:algorithmName".into(), "SHA-512".into()),
+        ("w:hashValue".into(), b64(&hash)),
+        ("w:saltValue".into(), b64(&salt)),
+        ("w:spinCount".into(), spin_count.to_string()),
+    ])
+}
+
+/// What checking a Restrict Editing password found ([`check_protection_password`]).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum PasswordCheck {
+    /// The protection has no password: anyone may stop it.
+    NoPassword,
+    /// The password matches the stored hash.
+    Correct,
+    /// The password doesn't match.
+    Incorrect,
+    /// The hash uses an algorithm or form WordCraft can't check, or is damaged. The protection
+    /// must stay on: guessing would let any password through.
+    Unsupported,
+}
+
+/// Does `password` match a Restrict Editing hash (attributes as [`protection_hash`] makes them, or
+/// as read from a file)? Two forms are checked:
+///
+/// - `w:algorithmName` / `w:hashValue` / `w:saltValue` / `w:spinCount`: the password itself is
+///   hashed ([`iterate_appended`]).
+/// - `w:cryptAlgorithmSid` / `w:hash` / `w:salt` / `w:cryptSpinCount` (ECMA-376 Part 4 §14.8.1):
+///   the password first becomes Word's legacy 32-bit key ([`legacy_key`]), whose bytes, reversed
+///   and written as an upper-case hex string, are hashed the same way.
+///
+/// Anything else — an algorithm other than SHA-1/SHA-256/SHA-384/SHA-512, an application-defined
+/// algorithm (`w:algIdExt`), a class other than `hash`, a spin count above the 10,000,000 Word
+/// accepts, damaged values — is [`PasswordCheck::Unsupported`], never a match.
+pub fn check_protection_password(attrs: &[(String, String)], password: &str) -> PasswordCheck {
+    let get = |k: &str| attrs.iter().find(|(n, _)| n == k).map(|(_, v)| v.trim());
+    if get("w:hashValue").is_some() {
+        let Some(hash) = get("w:algorithmName").and_then(Hash::parse) else { return PasswordCheck::Unsupported };
+        return verify(hash, get("w:hashValue"), get("w:saltValue"), get("w:spinCount"), password);
+    }
+    if get("w:hash").is_none() {
+        // §17.15.1.29: without a hash no password is associated with the protection.
+        return PasswordCheck::NoPassword;
+    }
+    let class_ok = get("w:cryptAlgorithmClass").is_none_or(|c| c == "hash");
+    let type_ok = get("w:cryptAlgorithmType").is_none_or(|t| t == "typeAny");
+    if !class_ok || !type_ok || get("w:algIdExt").is_some() {
+        return PasswordCheck::Unsupported;
+    }
+    // Part 4 §14.8.1 lists 1 MD2, 2 MD4, 3 MD5, 4 SHA-1, 12 SHA-256, 13 SHA-384, 14 SHA-512.
+    let hash = match get("w:cryptAlgorithmSid").and_then(|v| v.parse::<u32>().ok()) {
+        Some(4) => Hash::Sha1,
+        Some(12) => Hash::Sha256,
+        Some(13) => Hash::Sha384,
+        Some(14) => Hash::Sha512,
+        _ => return PasswordCheck::Unsupported,
+    };
+    verify(hash, get("w:hash"), get("w:salt"), get("w:cryptSpinCount"), &legacy_key_hex(password))
+}
+
+/// Hash `input` with the stored salt and spin count and compare with the stored hash. Damaged or
+/// out-of-range values are [`PasswordCheck::Unsupported`].
+fn verify(hash: Hash, want: Option<&str>, salt: Option<&str>, spin_count: Option<&str>, input: &str) -> PasswordCheck {
+    let dec = |v: &str| base64::engine::general_purpose::STANDARD.decode(v).ok();
+    let Some(want) = want.and_then(dec) else { return PasswordCheck::Unsupported };
+    // §17.15.1.29: without a salt nothing is prepended.
+    let salt = match salt {
+        Some(v) => match dec(v) {
+            Some(s) => s,
+            None => return PasswordCheck::Unsupported,
+        },
+        None => Vec::new(),
+    };
+    // Word accepts spin counts from 0 to 10,000,000 ([MS-OI29500] 2.1.402 d); a missing one is 0.
+    let spin_count = match spin_count.map(str::parse::<u32>) {
+        None => 0,
+        Some(Ok(n)) if n <= MAX_SPIN_COUNT => n,
+        Some(_) => return PasswordCheck::Unsupported,
+    };
+    if want.len() != hash.size() || salt.len() > 1024 {
+        return PasswordCheck::Unsupported;
+    }
+    if same(&iterate_appended(hash, &salt, input, spin_count), &want) { PasswordCheck::Correct } else { PasswordCheck::Incorrect }
+}
+
+/// The initial value of the legacy key's high-order word, by password length 1–15 (ECMA-376
+/// Part 4 §14.8.1, "Initial code array").
+const LEGACY_INITIAL_CODE: [u16; 15] =
+    [0xE1F0, 0x1D0F, 0xCC9C, 0x84C0, 0x110C, 0x0E10, 0xF1CE, 0x313E, 0x1872, 0xE139, 0xD40F, 0x84F9, 0x280C, 0xA96A, 0x4EC3];
+
+/// The legacy key's encryption matrix (Part 4 §14.8.1): one row per character position, rows
+/// "Last-14" to "Last", one column per bit 0–6. The password's last character uses the last row.
+const LEGACY_MATRIX: [[u16; 7]; 15] = [
+    [0xAEFC, 0x4DD9, 0x9BB2, 0x2745, 0x4E8A, 0x9D14, 0x2A09],
+    [0x7B61, 0xF6C2, 0xFDA5, 0xEB6B, 0xC6F7, 0x9DCF, 0x2BBF],
+    [0x4563, 0x8AC6, 0x05AD, 0x0B5A, 0x16B4, 0x2D68, 0x5AD0],
+    [0x0375, 0x06EA, 0x0DD4, 0x1BA8, 0x3750, 0x6EA0, 0xDD40],
+    [0xD849, 0xA0B3, 0x5147, 0xA28E, 0x553D, 0xAA7A, 0x44D5],
+    [0x6F45, 0xDE8A, 0xAD35, 0x4A4B, 0x9496, 0x390D, 0x721A],
+    [0xEB23, 0xC667, 0x9CEF, 0x29FF, 0x53FE, 0xA7FC, 0x5FD9],
+    [0x47D3, 0x8FA6, 0x0F6D, 0x1EDA, 0x3DB4, 0x7B68, 0xF6D0],
+    [0xB861, 0x60E3, 0xC1C6, 0x93AD, 0x377B, 0x6EF6, 0xDDEC],
+    [0x45A0, 0x8B40, 0x06A1, 0x0D42, 0x1A84, 0x3508, 0x6A10],
+    [0xAA51, 0x4483, 0x8906, 0x022D, 0x045A, 0x08B4, 0x1168],
+    [0x76B4, 0xED68, 0xCAF1, 0x85C3, 0x1BA7, 0x374E, 0x6E9C],
+    [0x3730, 0x6E60, 0xDCC0, 0xA9A1, 0x4363, 0x86C6, 0x1DAD],
+    [0x3331, 0x6662, 0xCCC4, 0x89A9, 0x0373, 0x06E6, 0x0DCC],
+    [0x1021, 0x2042, 0x4084, 0x8108, 0x1231, 0x2462, 0x48C4],
+];
+
+/// Word's legacy 32-bit password key (ECMA-376 Part 4 §14.8.1): the password as UTF-16 without a
+/// leading BOM, cut to 15 characters, each character reduced to one byte (its low byte, or its
+/// high byte when the low byte is 0); the high-order word comes from the initial code array and
+/// the encryption matrix, the low-order word from rotating and XOR-ing the bytes backwards.
+fn legacy_key(password: &str) -> u32 {
+    let mut units = password.encode_utf16().peekable();
+    units.next_if_eq(&0xFEFF);
+    let bytes: Zeroizing<Vec<u8>> =
+        Zeroizing::new(units.take(LEGACY_INITIAL_CODE.len()).map(|u| if u & 0xFF != 0 { (u & 0xFF) as u8 } else { (u >> 8) as u8 }).collect());
+    let Some(&initial) = bytes.len().checked_sub(1).and_then(|i| LEGACY_INITIAL_CODE.get(i)) else { return 0 };
+    let mut high = initial;
+    let first_row = LEGACY_MATRIX.len() - bytes.len();
+    for (row, &c) in LEGACY_MATRIX.iter().skip(first_row).zip(bytes.iter()) {
+        for (bit, &code) in row.iter().enumerate() {
+            if c & (1 << bit) != 0 {
+                high ^= code;
+            }
+        }
+    }
+    let rotate = |w: u16| ((w >> 14) & 0x0001) | ((w << 1) & 0x7FFF);
+    let mut low = 0u16;
+    for &c in bytes.iter().rev() {
+        low = rotate(low) ^ u16::from(c);
+    }
+    // `bytes` holds at most 15 values, so its length fits a word.
+    low = rotate(low) ^ (bytes.len() as u16) ^ 0xCE4B;
+    (u32::from(high) << 16) | u32::from(low)
+}
+
+/// What the legacy form hashes: the key's bytes in reversed order (Part 4 §14.8.1: 0x64CEED7E
+/// becomes 7EEDCE64), as an upper-case hex string — hashed as UTF-16LE like a password, as Word
+/// does ([MS-OE376] 2.1.410 a).
+fn legacy_key_hex(password: &str) -> Zeroizing<String> {
+    let key = legacy_key(password);
+    Zeroizing::new(key.to_le_bytes().iter().map(|b| format!("{b:02X}")).collect())
+}
+
+/// The ISO write-protection hash ([MS-OFFCRYPTO] §2.4.2.4): H0 = H(salt + password as UTF-16LE),
+/// Hn = H(Hn-1 + iterator) — the iterator after the hash, unlike encryption's [`iterate`].
+fn iterate_appended(hash: Hash, salt: &[u8], password: &str, spin_count: u32) -> Zeroizing<Vec<u8>> {
+    let pw: Zeroizing<Vec<u8>> = Zeroizing::new(password.encode_utf16().flat_map(u16::to_le_bytes).collect());
+    let mut h = Zeroizing::new(hash.hash(&[salt, &pw]));
+    for i in 0..spin_count.min(MAX_SPIN_COUNT) {
+        *h = hash.hash(&[&h, &i.to_le_bytes()]);
+    }
+    h
+}
+
 fn bad(msg: impl Into<String>) -> DocxError {
     DocxError::Encryption(msg.into())
 }
@@ -626,6 +795,72 @@ fn primary_transform() -> Vec<u8> {
 
 #[cfg(test)]
 mod tests {
+    #[test]
+    fn protection_password_round_trip() {
+        use super::PasswordCheck::*;
+        let attrs = super::protection_hash("s3cret", 1000).unwrap();
+        assert_eq!(super::check_protection_password(&attrs, "s3cret"), Correct);
+        assert_eq!(super::check_protection_password(&attrs, "S3cret"), Incorrect);
+        // Damaged attributes are refused, never accepted.
+        let mut bad = attrs.clone();
+        bad.retain(|(k, _)| k != "w:hashValue");
+        bad.push(("w:hashValue".into(), "not base64!".into()));
+        assert_eq!(super::check_protection_password(&bad, "s3cret"), Unsupported);
+        let mut odd = attrs.clone();
+        odd.retain(|(k, _)| k != "w:algorithmName");
+        odd.push(("w:algorithmName".into(), "WHIRLPOOL".into()));
+        assert_eq!(super::check_protection_password(&odd, "s3cret"), Unsupported);
+        assert_eq!(super::check_protection_password(&[("w:cryptProviderType".into(), "rsaAES".into())], "x"), NoPassword);
+    }
+
+    /// The worked example of ECMA-376 Part 4 §14.8.1: "Example" gives the key 0x64CEED7E, hashed
+    /// as "7EEDCE64".
+    #[test]
+    fn legacy_key_matches_the_specification_example() {
+        assert_eq!(super::legacy_key("Example"), 0x64CE_ED7E);
+        assert_eq!(super::legacy_key_hex("Example").as_str(), "7EEDCE64");
+        assert_eq!(super::legacy_key(""), 0);
+        // A leading BOM is dropped; only the first 15 characters count.
+        assert_eq!(super::legacy_key("\u{FEFF}Example"), 0x64CE_ED7E);
+        assert_eq!(super::legacy_key("abcdefghijklmnopq"), super::legacy_key("abcdefghijklmno"));
+        assert_ne!(super::legacy_key("abcdefghijklmno"), super::legacy_key("abcdefghijklmn"));
+    }
+
+    /// The legacy form (`w:cryptAlgorithmSid`, `w:hash`, `w:salt`, `w:cryptSpinCount`), as Word
+    /// writes it. The expected hash was computed independently from the specification's stages.
+    #[test]
+    fn legacy_protection_hash_is_verified() {
+        use super::PasswordCheck::*;
+        let legacy = |sid: &str, hash: &str, spin: &str| -> Vec<(String, String)> {
+            vec![
+                ("w:cryptProviderType".into(), "rsaFull".into()),
+                ("w:cryptAlgorithmClass".into(), "hash".into()),
+                ("w:cryptAlgorithmType".into(), "typeAny".into()),
+                ("w:cryptAlgorithmSid".into(), sid.into()),
+                ("w:cryptSpinCount".into(), spin.into()),
+                ("w:hash".into(), hash.into()),
+                ("w:salt".into(), "AAECAwQFBgcICQoLDA0ODw==".into()),
+            ]
+        };
+        let attrs = legacy("4", KNOWN_LEGACY_SHA1, "100000");
+        assert_eq!(super::check_protection_password(&attrs, "Example"), Correct);
+        assert_eq!(super::check_protection_password(&attrs, "example"), Incorrect);
+        assert_eq!(super::check_protection_password(&attrs, ""), Incorrect);
+        // MD5 (and the other algorithms WordCraft lacks), hostile spin counts: refused.
+        assert_eq!(super::check_protection_password(&legacy("3", KNOWN_LEGACY_SHA1, "100000"), "Example"), Unsupported);
+        assert_eq!(super::check_protection_password(&legacy("4", KNOWN_LEGACY_SHA1, "4294967295"), "Example"), Unsupported);
+        assert_eq!(super::check_protection_password(&legacy("4", KNOWN_LEGACY_SHA1, "-1"), "Example"), Unsupported);
+        let mut ext = attrs.clone();
+        ext.push(("w:algIdExt".into(), "0000000A".into()));
+        assert_eq!(super::check_protection_password(&ext, "Example"), Unsupported);
+        // No algorithm named: the very old bare-hash form isn't defined, so it's refused.
+        let bare = vec![("w:hash".to_string(), KNOWN_LEGACY_SHA1.to_string())];
+        assert_eq!(super::check_protection_password(&bare, "Example"), Unsupported);
+    }
+
+    /// SHA-1 of the salt 00 01 … 0F and "7EEDCE64" as UTF-16LE, iterated 100,000 times.
+    const KNOWN_LEGACY_SHA1: &str = "pEWelKoH6SVpvMmyPAJ8bHA/g/s=";
+
     use super::*;
 
     fn zip_package() -> Vec<u8> {
diff --git a/crates/docx/src/flat.rs b/crates/docx/src/flat.rs
new file mode 100644
index 0000000000..f0949a200b
--- /dev/null
+++ b/crates/docx/src/flat.rs
@@ -0,0 +1,411 @@
+//! Word XML Document: a whole WordprocessingML package as one XML file (the Flat OPC format Word
+//! saves as "Word XML Document (*.xml)"): a `pkg:package` root holding one `pkg:part` per package
+//! part, each with its name and content type, and the part's XML inline (`pkg:xmlData`) or its
+//! bytes in base64 (`pkg:binaryData`).
+//!
+//! Reading unpacks the parts into an in-memory [`Package`] and hands it to the DOCX reader;
+//! writing runs the DOCX writer and lays its parts out in one file. Bounded like the zip reader:
+//! part count, part size, total size and base64 length are capped.
+
+use std::collections::BTreeMap;
+
+use base64::Engine as _;
+use quick_xml::events::{BytesStart, Event};
+use quick_xml::name::ResolveResult;
+use quick_xml::reader::NsReader;
+use wordcraft_doc::Document;
+
+use crate::package::{ContentTypes, MAX_ENTRIES, MAX_PART, MAX_TOTAL, Package};
+use crate::xml::{self, W, esc};
+use crate::{DocxError, Flavor};
+
+/// The Flat OPC package namespace.
+pub const PKG_NS: &str = "http://schemas.microsoft.com/office/2006/xmlPackage";
+/// The WordprocessingML 2003 namespace (Word 2003 XML Document).
+pub const W2003_NS: &str = "http://schemas.microsoft.com/office/word/2003/wordml";
+
+/// What kind of XML file a `.xml` holds.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum XmlKind {
+    /// A Flat OPC package (Word XML Document, Word 2007 and later).
+    FlatOpc,
+    /// A Word 2003 XML Document (WordprocessingML 2003).
+    WordMl2003,
+    /// Some other XML, or not XML at all.
+    Other,
+}
+
+/// Elements and declarations looked at before the root element (comments, processing
+/// instructions) before giving up.
+const MAX_PROLOG_EVENTS: usize = 10_000;
+
+/// The text of `bytes` as UTF-8: UTF-16 with a byte-order mark is transcoded, a UTF-8 one dropped.
+fn utf8_text(bytes: &[u8]) -> std::borrow::Cow<'_, [u8]> {
+    match xml::utf16_to_utf8(bytes) {
+        Some(s) => std::borrow::Cow::Owned(s.into_bytes()),
+        None => std::borrow::Cow::Borrowed(bytes.strip_prefix(&[0xEF, 0xBB, 0xBF][..]).unwrap_or(bytes)),
+    }
+}
+
+/// Tell a Word XML file by its root element: `pkg:package` (Flat OPC) or `w:wordDocument`
+/// (Word 2003), each in its namespace.
+pub fn sniff_xml(bytes: &[u8]) -> XmlKind {
+    let text = utf8_text(bytes);
+    let mut r = NsReader::from_reader(text.as_ref());
+    for _ in 0..MAX_PROLOG_EVENTS {
+        match r.read_resolved_event() {
+            Ok((res, Event::Start(e) | Event::Empty(e))) => {
+                let ns = match res {
+                    ResolveResult::Bound(ns) => ns.as_ref().to_vec(),
+                    _ => Vec::new(),
+                };
+                return match (e.local_name().as_ref(), ns.as_slice()) {
+                    (b"package", ns) if ns == PKG_NS.as_bytes() => XmlKind::FlatOpc,
+                    (b"wordDocument", ns) if ns == W2003_NS.as_bytes() => XmlKind::WordMl2003,
+                    _ => XmlKind::Other,
+                };
+            }
+            Ok((_, Event::Eof)) | Err(_) => return XmlKind::Other,
+            Ok(_) => {}
+        }
+    }
+    XmlKind::Other
+}
+
+/// Read a Flat OPC file.
+pub fn read(bytes: &[u8]) -> Result<Document, DocxError> {
+    crate::read::read_opened(&unpack(bytes)?)
+}
+
+/// The data element of the part being read.
+enum Data {
+    /// `pkg:xmlData`: its content starts at this byte offset.
+    Xml(usize),
+    /// `pkg:binaryData`: the base64 text so far.
+    Binary(String),
+}
+
+/// The part being read: name, content type, data.
+struct Part {
+    name: String,
+    content_type: String,
+    data: Option<Data>,
+}
+
+/// Longest base64 text of one part (the size limit, encoded; whitespace isn't kept).
+const MAX_BASE64: u64 = (MAX_PART / 3 + 1) * 4;
+
+/// Unpack a Flat OPC file into its parts, with a `[Content_Types].xml` made from the parts'
+/// content types (unless the file carries one).
+pub(crate) fn unpack(bytes: &[u8]) -> Result<Package, DocxError> {
+    let text = utf8_text(bytes);
+    let src: &[u8] = text.as_ref();
+    let mut r = NsReader::from_reader(src);
+    r.config_mut().check_end_names = true;
+    let mut depth = 0usize;
+    let mut files: BTreeMap<String, Vec<u8>> = BTreeMap::new();
+    let mut types: Vec<(String, String)> = Vec::new();
+    let mut total: u64 = 0;
+    let mut part: Option<Part> = None;
+    // `xmlns` declarations on the package, part and data elements, in scope for the inline XML.
+    let mut scope: Vec<Vec<(String, String)>> = Vec::new();
+    let bad = |e: quick_xml::Error| DocxError::Xml(e.to_string());
+    loop {
+        let before = usize::try_from(r.buffer_position()).unwrap_or(usize::MAX);
+        let (res, ev) = r.read_resolved_event().map_err(bad)?;
+        let in_pkg = matches!(&res, ResolveResult::Bound(ns) if ns.as_ref() == PKG_NS.as_bytes());
+        match ev {
+            Event::Start(ref e) | Event::Empty(ref e) => {
+                let empty = matches!(ev, Event::Empty(_));
+                depth += 1;
+                let local = e.local_name().as_ref().to_vec();
+                match depth {
+                    1 if !(in_pkg && local == b"package") => {
+                        return Err(DocxError::NotWord("the root element isn't a Flat OPC pkg:package".into()));
+                    }
+                    2 if in_pkg && local == b"part" => {
+                        if files.len() + usize::from(part.is_some()) >= MAX_ENTRIES {
+                            return Err(DocxError::Limit(format!("more than {MAX_ENTRIES} parts")));
+                        }
+                        let name = attr(e, b"name").unwrap_or_default();
+                        let content_type = attr(e, b"contentType").unwrap_or_default();
+                        part = Some(Part { name, content_type, data: None });
+                    }
+                    3 if in_pkg => {
+                        if let Some(p) = part.as_mut().filter(|p| p.data.is_none()) {
+                            let pos = usize::try_from(r.buffer_position()).unwrap_or(usize::MAX);
+                            p.data = match local.as_slice() {
+                                // `<pkg:xmlData/>`: an empty part.
+                                b"xmlData" if empty => Some(Data::Binary(String::new())),
+                                b"xmlData" => Some(Data::Xml(pos)),
+                                b"binaryData" => Some(Data::Binary(String::new())),
+                                _ => None,
+                            };
+                        }
+                    }
+                    _ => {}
+                }
+                if depth <= 3 {
+                    scope.push(ns_decls(e));
+                }
+                if empty {
+                    if depth == 2
+                        && let Some(p) = part.take()
+                    {
+                        finish_part(p, &mut files, &mut types, &mut total)?;
+                    }
+                    if depth <= 3 {
+                        scope.pop();
+                    }
+                    depth -= 1;
+                }
+            }
+            Event::End(_) => {
+                // The inline XML ends where its data element's end tag starts.
+                if depth == 3
+                    && let Some(p) = part.as_mut()
+                    && let Some(Data::Xml(start)) = p.data
+                {
+                    p.data = None;
+                    let xml = with_scope(src.get(start..before).unwrap_or_default(), &scope);
+                    store(&p.name, &p.content_type, xml, &mut files, &mut types, &mut total)?;
+                }
+                if depth == 2
+                    && let Some(p) = part.take()
+                {
+                    finish_part(p, &mut files, &mut types, &mut total)?;
+                }
+                if depth <= 3 {
+                    scope.pop();
+                }
+                depth = depth.saturating_sub(1);
+                if depth == 0 {
+                    break;
+                }
+            }
+            Event::Text(ref t) if depth == 3 => {
+                if let Some(Part { data: Some(Data::Binary(b64)), .. }) = part.as_mut() {
+                    let s = std::str::from_utf8(t.as_ref()).map_err(|e| DocxError::Xml(e.to_string()))?;
+                    b64.extend(s.chars().filter(|c| !c.is_ascii_whitespace()));
+                    if b64.len() as u64 > MAX_BASE64 {
+                        return Err(DocxError::Limit("a binary part is larger than the size limit".into()));
+                    }
+                }
+            }
+            Event::Eof => break,
+            _ => {}
+        }
+    }
+    if files.is_empty() {
+        return Err(DocxError::NotWord("the Flat OPC package has no parts".into()));
+    }
+    if !files.contains_key("[Content_Types].xml") {
+        let mut w = W::new();
+        w.open("Types", &[("xmlns", "http://schemas.openxmlformats.org/package/2006/content-types")]);
+        for (name, ct) in &types {
+            w.empty("Override", &[("PartName", &format!("/{name}")), ("ContentType", ct)]);
+        }
+        w.close("Types");
+        files.insert("[Content_Types].xml".into(), w.into_bytes());
+    }
+    Ok(Package::from_parts(files))
+}
+
+/// End of a `pkg:part`: store its binary data (inline XML was stored when it ended).
+fn finish_part(p: Part, files: &mut BTreeMap<String, Vec<u8>>, types: &mut Vec<(String, String)>, total: &mut u64) -> Result<(), DocxError> {
+    match p.data {
+        Some(Data::Binary(b64)) => {
+            let bytes = base64::engine::general_purpose::STANDARD_NO_PAD
+                .decode(b64.trim_end_matches('='))
+                .map_err(|_| DocxError::Xml(format!("part {} has invalid base64 data", p.name)))?;
+            store(&p.name, &p.content_type, bytes, files, types, total)
+        }
+        // A part without data, or whose inline XML was already stored.
+        _ => Ok(()),
+    }
+}
+
+/// Add a part, within the size limits; a repeated or empty name is ignored.
+fn store(
+    name: &str,
+    content_type: &str,
+    bytes: Vec<u8>,
+    files: &mut BTreeMap<String, Vec<u8>>,
+    types: &mut Vec<(String, String)>,
+    total: &mut u64,
+) -> Result<(), DocxError> {
+    let name = name.trim_start_matches('/');
+    if name.is_empty() || files.contains_key(name) {
+        return Ok(());
+    }
+    let len = bytes.len() as u64;
+    if len > MAX_PART {
+        return Err(DocxError::Limit(format!("part {name} is larger than the size limit")));
+    }
+    *total = total.saturating_add(len);
+    if *total > MAX_TOTAL {
+        return Err(DocxError::Limit("the package is larger than the size limit".into()));
+    }
+    if !content_type.is_empty() && !content_type.contains(['\r', '\n']) {
+        types.push((name.to_string(), content_type.to_string()));
+    }
+    files.insert(name.to_string(), bytes);
+    Ok(())
+}
+
+/// An attribute's unescaped value, by local name (any prefix).
+fn attr(e: &BytesStart, local: &[u8]) -> Option<String> {
+    e.attributes().with_checks(false).flatten().find(|a| a.key.local_name().as_ref() == local).map(|a| {
+        match a.normalized_value(quick_xml::XmlVersion::Explicit1_0) {
+            Ok(v) => v.into_owned(),
+            Err(_) => String::from_utf8_lossy(&a.value).into_owned(),
+        }
+    })
+}
+
+/// The `xmlns` / `xmlns:p` declarations of a start tag, as written (value still escaped).
+fn ns_decls(e: &BytesStart) -> Vec<(String, String)> {
+    e.attributes()
+        .with_checks(false)
+        .flatten()
+        .filter(|a| a.key.as_ref() == b"xmlns" || a.key.as_ref().starts_with(b"xmlns:"))
+        .filter(|a| !a.value.contains(&b'"'))
+        .map(|a| (String::from_utf8_lossy(a.key.as_ref()).into_owned(), String::from_utf8_lossy(&a.value).into_owned()))
+        .take(256)
+        .collect()
+}
+
+/// The inline XML of a part as a document of its own: namespaces it inherits from the package
+/// elements are declared on its root element (unless it declares them itself).
+fn with_scope(frag: &[u8], scope: &[Vec<(String, String)>]) -> Vec<u8> {
+    let decls: Vec<&(String, String)> = scope.iter().flatten().filter(|(k, _)| k != "xmlns:pkg").collect();
+    let Some(open) = root_tag_start(frag) else { return frag.to_vec() };
+    if decls.is_empty() {
+        return frag.get(open..).unwrap_or_default().to_vec();
+    }
+    let rest = frag.get(open..).unwrap_or_default();
+    let name_end = rest.iter().position(|b| b.is_ascii_whitespace() || *b == b'>' || *b == b'/').unwrap_or(rest.len());
+    let tag_end = rest.iter().position(|b| *b == b'>').unwrap_or(rest.len());
+    let tag = rest.get(..tag_end).unwrap_or_default();
+    let mut out = Vec::with_capacity(rest.len() + 256);
+    out.extend_from_slice(rest.get(..name_end).unwrap_or_default());
+    // Innermost declarations win: walk from the data element out, skipping prefixes seen.
+    let mut seen: Vec<&str> = Vec::new();
+    for (k, v) in decls.iter().rev() {
+        let declared = tag.windows(k.len() + 1).any(|w| w.get(..k.len()) == Some(k.as_bytes()) && matches!(w.last(), Some(b'=' | b' ')));
+        if declared || seen.contains(&k.as_str()) {
+            continue;
+        }
+        seen.push(k);
+        out.extend_from_slice(format!(" {k}=\"{v}\"").as_bytes());
+    }
+    out.extend_from_slice(rest.get(name_end..).unwrap_or_default());
+    out
+}
+
+/// Offset of the `<` of the first element in `frag` (after whitespace, comments and processing
+/// instructions).
+fn root_tag_start(frag: &[u8]) -> Option<usize> {
+    let mut i = 0usize;
+    loop {
+        while frag.get(i).is_some_and(u8::is_ascii_whitespace) {
+            i += 1;
+        }
+        let rest = frag.get(i..)?;
+        if rest.starts_with(b"<!--") {
+            i += rest.windows(3).position(|w| w == b"-->")? + 3;
+        } else if rest.starts_with(b"<?") {
+            i += rest.windows(2).position(|w| w == b"?>")? + 2;
+        } else if rest.first() == Some(&b'<') {
+            return Some(i);
+        } else {
+            return None;
+        }
+    }
+}
+
+/// Write `doc` as a Word XML Document (Flat OPC).
+pub fn write(doc: &Document) -> Result<Vec<u8>, DocxError> {
+    let parts = crate::write::write_parts(doc, Flavor::Document)?;
+    let types = parts
+        .iter()
+        .find(|(n, _)| n == "[Content_Types].xml")
+        .map(|(n, b)| ContentTypes::read(&Package::from_parts(BTreeMap::from([(n.clone(), b.clone())]))))
+        .unwrap_or_default();
+    let mut s = String::from("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n<?mso-application progid=\"Word.Document\"?>\n");
+    s.push_str(&format!("<pkg:package xmlns:pkg=\"{PKG_NS}\">"));
+    for (name, bytes) in &parts {
+        if name == "[Content_Types].xml" {
+            continue;
+        }
+        let ct = types.of(name).unwrap_or("application/octet-stream");
+        s.push_str(&format!("<pkg:part pkg:name=\"/{}\" pkg:contentType=\"{}\"", esc(name), esc(ct)));
+        match xml_fragment(ct, bytes) {
+            Some(x) => {
+                s.push_str("><pkg:xmlData>");
+                s.push_str(x);
+                s.push_str("</pkg:xmlData></pkg:part>");
+            }
+            None => {
+                s.push_str(" pkg:compression=\"store\"><pkg:binaryData>");
+                let b64 = base64::engine::general_purpose::STANDARD.encode(bytes);
+                for (i, chunk) in b64.as_bytes().chunks(76).enumerate() {
+                    if i > 0 {
+                        s.push('\n');
+                    }
+                    s.push_str(std::str::from_utf8(chunk).unwrap_or_default());
+                }
+                s.push_str("</pkg:binaryData></pkg:part>");
+            }
+        }
+    }
+    s.push_str("</pkg:package>");
+    Ok(s.into_bytes())
+}
+
+/// An XML part's markup without its XML declaration, to inline as `pkg:xmlData`; `None` for
+/// a part that isn't UTF-8 XML (or has a DOCTYPE), which goes in base64.
+fn xml_fragment<'a>(ct: &str, bytes: &'a [u8]) -> Option<&'a str> {
+    let ct = ct.to_ascii_lowercase();
+    if !(ct.ends_with("+xml") || ct.ends_with("/xml")) {
+        return None;
+    }
+    let s = std::str::from_utf8(bytes).ok()?;
+    let s = s.strip_prefix('\u{FEFF}').unwrap_or(s).trim_start();
+    let s = match s.strip_prefix("<?xml") {
+        Some(rest) => rest.split_once("?>").map(|(_, r)| r)?.trim_start(),
+        None => s,
+    };
+    (s.starts_with('<') && !s.contains("<!DOCTYPE")).then_some(s)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn sniffs_root_elements() {
+        assert_eq!(
+            sniff_xml(
+                format!("<?xml version=\"1.0\"?><?mso-application progid=\"Word.Document\"?><!-- x --><p:package xmlns:p=\"{PKG_NS}\"/>").as_bytes()
+            ),
+            XmlKind::FlatOpc
+        );
+        assert_eq!(sniff_xml(format!("\u{FEFF}<w:wordDocument xmlns:w=\"{W2003_NS}\"/>").as_bytes()), XmlKind::WordMl2003);
+        assert_eq!(sniff_xml(b"<package/>"), XmlKind::Other);
+        assert_eq!(sniff_xml(b"<html><body/></html>"), XmlKind::Other);
+        assert_eq!(sniff_xml(b"\x00\xff garbage"), XmlKind::Other);
+        assert_eq!(sniff_xml(b""), XmlKind::Other);
+    }
+
+    #[test]
+    fn inline_xml_inherits_namespaces_from_the_package() {
+        let frag = b"\n <!-- c --> <w:document><w:body/></w:document>";
+        let scope = vec![vec![("xmlns:pkg".to_string(), PKG_NS.to_string()), ("xmlns:w".to_string(), "urn:w".to_string())]];
+        let out = String::from_utf8(with_scope(frag, &scope)).unwrap();
+        assert_eq!(out, "<w:document xmlns:w=\"urn:w\"><w:body/></w:document>");
+        let own = b"<w:document xmlns:w=\"urn:own\"/>";
+        assert_eq!(with_scope(own, &scope), own.to_vec());
+        assert_eq!(with_scope(b"no element", &scope), b"no element".to_vec());
+    }
+}
diff --git a/crates/docx/src/lib.rs b/crates/docx/src/lib.rs
index 8845ef4b3d..e5895d32fb 100644
--- a/crates/docx/src/lib.rs
+++ b/crates/docx/src/lib.rs
@@ -7,18 +7,45 @@
 //! error or a best-effort document, never a panic.
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
+mod chart_spec;
 mod crypt;
 mod custom;
+mod flat;
 mod package;
 mod read;
+mod smart_art;
 mod units;
+mod wordml2003;
 mod write;
 mod xml;
 
-pub use crypt::{DEFAULT_SPIN_COUNT, MAX_PASSWORD_CHARS, check_password, decrypt, encrypt, encrypt_with_spin_count, is_encrypted};
+pub use chart_spec::{chart_items, chart_xml};
+pub use crypt::{
+    DEFAULT_SPIN_COUNT, MAX_PASSWORD_CHARS, PasswordCheck, check_password, check_protection_password, decrypt, encrypt, encrypt_with_spin_count,
+    is_encrypted, protection_hash,
+};
+pub use flat::{XmlKind, sniff_xml, write as write_flat};
 pub use read::read;
+pub use smart_art::smart_art_items;
 pub use write::{write, write_as};
 
+/// Largest `.xml` file read as a Word XML document.
+pub const MAX_XML_FILE: usize = 1 << 30;
+
+/// Read a Word XML file (`.xml`): a Word XML Document (Flat OPC, the whole package in one XML
+/// file) or a Word 2003 XML Document (WordprocessingML 2003), told apart by the root element.
+/// Any other XML gives [`DocxError::NotWordXml`].
+pub fn read_xml(bytes: &[u8]) -> Result<wordcraft_doc::Document, DocxError> {
+    if bytes.len() > MAX_XML_FILE {
+        return Err(DocxError::Limit(format!("XML file of {} bytes", bytes.len())));
+    }
+    match sniff_xml(bytes) {
+        XmlKind::FlatOpc => flat::read(bytes),
+        XmlKind::WordMl2003 => wordml2003::read(bytes),
+        XmlKind::Other => Err(DocxError::NotWordXml),
+    }
+}
+
 /// What [`DocxError::PasswordRequired`] says.
 pub const PASSWORD_REQUIRED: &str = "this document is protected with a password";
 /// What [`DocxError::WrongPassword`] says.
@@ -101,6 +128,9 @@ pub enum DocxError {
     /// The package is readable but isn't a WordprocessingML document.
     #[error("not a Word document: {0}")]
     NotWord(String),
+    /// An `.xml` file that is neither a Word XML Document (Flat OPC) nor Word 2003 XML.
+    #[error("not a Word XML document")]
+    NotWordXml,
     /// The package is encrypted and no password was given.
     #[error("{}", PASSWORD_REQUIRED)]
     PasswordRequired,
diff --git a/crates/docx/src/package.rs b/crates/docx/src/package.rs
index c3e3ebca1e..1e20db246a 100644
--- a/crates/docx/src/package.rs
+++ b/crates/docx/src/package.rs
@@ -19,9 +19,11 @@ pub mod rt {
     pub const CORE: &str = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
     pub const APP: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties";
     pub const CUSTOM: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties";
+    pub const CUSTOM_XML_PROPS: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXmlProps";
     pub const STYLES: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles";
     pub const NUMBERING: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering";
     pub const SETTINGS: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/settings";
+    pub const ATTACHED_TEMPLATE: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/attachedTemplate";
     pub const THEME: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme";
     pub const FOOTNOTES: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes";
     pub const ENDNOTES: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes";
@@ -35,6 +37,10 @@ pub mod rt {
     pub const CHART: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart";
     pub const DIAGRAM_DATA: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramData";
     pub const DIAGRAM_DRAWING: &str = "http://schemas.microsoft.com/office/2007/relationships/diagramDrawing";
+    pub const DIAGRAM_LAYOUT: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramLayout";
+    pub const DIAGRAM_QUICK_STYLE: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramQuickStyle";
+    pub const DIAGRAM_COLORS: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/diagramColors";
+    pub const CUSTOM_XML: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml";
 }
 
 /// `Document::passthrough` key for a macro project, kept as opaque bytes (never parsed or run).
@@ -51,6 +57,9 @@ pub const MAX_VBA_RELATED: usize = 64;
 /// types and own relationships, as [`EmbeddedManifest`] lines. Each part's bytes are kept under its
 /// part name. Not a package part: WordCraft's own bookkeeping.
 pub const EMBEDDED_PARTS: &str = "wordcraft:embedded.parts";
+/// Custom XML roots kept by the package (P) or main document (D): `owner\ttype\tpart`.
+/// Their opaque bytes and related parts use the same bounded manifest as embedded objects.
+pub const CUSTOM_XML_ROOTS: &str = "wordcraft:customXml.roots";
 /// Most parts we carry along for a file's embedded objects.
 pub const MAX_EMBEDDED_PARTS: usize = 4096;
 /// Most relationships we keep for one such part.
@@ -174,6 +183,12 @@ impl Package {
         Ok(Package { files })
     }
 
+    /// A package from parts already in memory (a Flat OPC file, a converted document), by part
+    /// name without the leading `/`.
+    pub fn from_parts(files: BTreeMap<String, Vec<u8>>) -> Package {
+        Package { files }
+    }
+
     /// Part bytes by name (leading `/` ignored; case-insensitive fallback).
     pub fn get(&self, name: &str) -> Option<&[u8]> {
         let n = name.trim_start_matches('/');
diff --git a/crates/docx/src/read/chart.rs b/crates/docx/src/read/chart.rs
index 004949f6a6..70cde2871a 100644
--- a/crates/docx/src/read/chart.rs
+++ b/crates/docx/src/read/chart.rs
@@ -1,8 +1,8 @@
 //! Charts (ECMA-376 Part 1 §21.2): the cached data of a `c:chartSpace` drawn as items in points.
 //!
 //! Bar and column (clustered, stacked or 100% stacked), line, area, pie, doughnut and scatter
-//! charts are drawn from the first supported chart type of the plot area. Other chart types draw
-//! nothing. Text widths are estimated ([`CHAR_W`] em a character), so label places are approximate.
+//! charts are drawn from the first supported chart type of the plot area, with their values as
+//! data labels where `c:dLbls` shows them (`c:showVal`). Other chart types draw nothing. Text widths are estimated ([`CHAR_W`] em a character), so label places are approximate.
 
 use std::f64::consts::{FRAC_PI_2, TAU};
 
@@ -78,6 +78,15 @@ pub(crate) fn chart_items(space: &El, theme: &[Rgb], w: f32, h: f32) -> Vec<Grap
     out
 }
 
+/// A data label to draw once the chart is: the value at (`x`, `y`), centred there (`inside`, in
+/// white on the fill) or just beside it (above, or right of a horizontal bar's end).
+struct DataLabel {
+    x: f32,
+    y: f32,
+    text: String,
+    inside: bool,
+}
+
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 enum Kind {
     Bar,
@@ -145,6 +154,11 @@ struct Series {
     fmt: Option<String>,
     /// Format code of the scatter x values' cache.
     x_fmt: Option<String>,
+    /// Data labels on or off for this series (`c:dLbls` of its own), when it says.
+    labels: Option<bool>,
+    /// The values as the file has them, for data labels (`values` become shares in a 100%
+    /// stacked chart); empty when the series shows no labels.
+    raw: Vec<Option<f64>>,
 }
 
 struct Chart {
@@ -206,9 +220,14 @@ impl Chart {
         };
         let mut cats = cats;
         cats.resize(n, String::new());
+        let type_labels = show_values(ty.child("c:dLbls"));
         for s in &mut series {
             s.values.resize(n, None);
             s.xs.resize(n, None);
+            s.labels = Some(s.labels.or(type_labels).unwrap_or(false));
+            if s.labels == Some(true) {
+                s.raw = s.values.clone();
+            }
         }
         if grouping == Grouping::Percent {
             to_percent(&mut series, n);
@@ -329,6 +348,15 @@ fn title_of(chart: &El, series: &[Series]) -> Option<String> {
     chart.child("c:title").and_then(|t| title_text(t).or(auto))
 }
 
+/// Whether a `c:dLbls` shows the values (`None` when there's none, or it doesn't say).
+fn show_values(d: Option<&El>) -> Option<bool> {
+    let d = d?;
+    if d.child("c:delete").and_then(|e| e.attr("val")).is_some_and(truthy) {
+        return Some(false);
+    }
+    d.child("c:showVal").map(|v| v.attr("val").is_none_or(truthy))
+}
+
 fn legend_pos(chart: &El) -> Option<Pos> {
     chart.child("c:legend").map(|l| match l.child("c:legendPos").and_then(|p| p.attr("val")).unwrap_or("r") {
         "l" => Pos::Left,
@@ -370,7 +398,8 @@ impl Series {
                 *slot = c;
             }
         }
-        Series { name, color, line_w, line, values, xs, points, fmt, x_fmt }
+        let labels = show_values(ser.child("c:dLbls"));
+        Series { name, color, line_w, line, values, xs, points, fmt, x_fmt, labels, raw: Vec::new() }
     }
 }
 
@@ -1240,14 +1269,16 @@ fn cartesian(out: &mut Vec<GraphicItem>, c: &Chart, area: Rect) {
     if c.val.grid {
         draw_grid(out, &g, &ax.vticks);
     }
+    let mut labels = Vec::new();
     match c.kind {
-        Kind::Bar => bars(out, c, &g),
-        Kind::Line => lines(out, c, &g),
-        Kind::Area => areas(out, c, &g),
-        Kind::Scatter => draw_scatter(out, c, &g),
+        Kind::Bar => bars(out, c, &g, &mut labels),
+        Kind::Line => lines(out, c, &g, &mut labels),
+        Kind::Area => areas(out, c, &g, &mut labels),
+        Kind::Scatter => draw_scatter(out, c, &g, &mut labels),
         Kind::Pie | Kind::Doughnut => {}
     }
     draw_axes(out, c, &g);
+    draw_data_labels(out, &labels, c.text_size, g.horiz && c.kind == Kind::Bar);
     if !c.val.deleted {
         draw_value_labels(out, c, &g, &ax.vticks, Rect { w: m.left, ..area });
     }
@@ -1367,7 +1398,7 @@ fn x_extent(c: &Chart) -> (f64, f64) {
     if lo.is_finite() && hi.is_finite() { (lo, hi) } else { (0.0, 1.0) }
 }
 
-fn bars(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame) {
+fn bars(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame, labels: &mut Vec<DataLabel>) {
     let stacked = c.stacked();
     let slots = if stacked { 1 } else { c.series.len().max(1) };
     let ov = if stacked { 0.0 } else { c.overlap };
@@ -1400,6 +1431,17 @@ fn bars(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame) {
             let (p0, p1) = (p0.min(p1), p0.max(p1));
             let segs = if g.horiz { rect_segs(p0, a, p1, a + thick) } else { rect_segs(a, p0, a + thick, p1) };
             fill(out, segs, c.point_colour(j, i));
+            if let Some(text) = label_of(s, i) {
+                let mid = a + thick / 2.0;
+                let (x, y) = match (g.horiz, stacked) {
+                    (true, true) => ((p0 + p1) / 2.0, mid),
+                    (false, true) => (mid, (p0 + p1) / 2.0),
+                    // Beyond the bar's end: right of a positive bar, above a positive column.
+                    (true, false) => (if v >= 0.0 { p1 } else { p0 }, mid),
+                    (false, false) => (mid, if v >= 0.0 { p0 } else { p1 }),
+                };
+                labels.push(DataLabel { x, y, text, inside: stacked });
+            }
         }
     }
 }
@@ -1410,7 +1452,7 @@ fn has_values(s: &Series) -> bool {
 }
 
 /// Line series; stacked ones are drawn at the running total of the series up to them.
-fn lines(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame) {
+fn lines(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame, labels: &mut Vec<DataLabel>) {
     let mut total = vec![0.0f64; g.n];
     for (j, s) in c.series.iter().enumerate().filter(|(_, s)| has_values(s)) {
         let pts: Vec<Option<(f32, f32)>> = (0..g.n)
@@ -1426,11 +1468,16 @@ fn lines(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame) {
                 Some((g.cat_x(i), g.val(y)))
             })
             .collect();
+        for (i, p) in pts.iter().enumerate() {
+            if let (Some((x, y)), Some(text)) = (p, label_of(s, i)) {
+                labels.push(DataLabel { x: *x, y: *y, text, inside: false });
+            }
+        }
         stroke(out, runs(pts.into_iter()), c.series_colour(j), s.line_w);
     }
 }
 
-fn areas(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame) {
+fn areas(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame, labels: &mut Vec<DataLabel>) {
     let mut base = vec![0.0f64; g.n];
     for (j, s) in c.series.iter().enumerate().filter(|(_, s)| has_values(s)) {
         let vals = (0..g.n).map(|i| s.values.get(i).copied().flatten().unwrap_or(0.0));
@@ -1445,6 +1492,11 @@ fn areas(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame) {
         }
         segs.push(PathSeg::Close);
         fill(out, segs, c.series_colour(j));
+        for (i, (t, b)) in top.iter().zip(&base).enumerate() {
+            if let Some(text) = label_of(s, i) {
+                labels.push(DataLabel { x: g.cat_x(i), y: g.val((t + b) / 2.0), text, inside: true });
+            }
+        }
         if c.stacked() {
             base = top;
         }
@@ -1452,7 +1504,7 @@ fn areas(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame) {
 }
 
 /// Scatter series as lines, or as small markers when the series has no line.
-fn draw_scatter(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame) {
+fn draw_scatter(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame, labels: &mut Vec<DataLabel>) {
     const MARKER: f32 = 6.0;
     for (j, s) in c.series.iter().enumerate() {
         let pts: Vec<Option<(f32, f32)>> =
@@ -1463,6 +1515,11 @@ fn draw_scatter(out: &mut Vec<GraphicItem>, c: &Chart, g: &Frame) {
                     _ => None,
                 })
                 .collect();
+        for (i, p) in pts.iter().enumerate() {
+            if let (Some((x, y)), Some(text)) = (p, label_of(s, i)) {
+                labels.push(DataLabel { x: *x, y: *y - MARKER / 2.0, text, inside: false });
+            }
+        }
         if s.line {
             stroke(out, runs(pts.iter().copied()), c.series_colour(j), s.line_w);
             continue;
@@ -1485,6 +1542,7 @@ fn pie(out: &mut Vec<GraphicItem>, c: &Chart, area: Rect) {
     let (cx, cy) = ((area.x + area.w / 2.0) as f64, (area.y + area.h / 2.0) as f64);
     let inner = if c.kind == Kind::Doughnut { r * c.hole as f64 } else { 0.0 };
     let mut a = c.first_angle.to_radians();
+    let mut labels = Vec::new();
     for (i, v) in vals.iter().enumerate() {
         if *v <= 0.0 {
             continue;
@@ -1503,8 +1561,57 @@ fn pie(out: &mut Vec<GraphicItem>, c: &Chart, area: Rect) {
         }
         segs.push(PathSeg::Close);
         fill(out, segs, c.point_colour(0, i));
+        if let Some(text) = label_of(s, i) {
+            // Halfway across the ring (pie: two thirds out from the centre).
+            let at = if inner > 0.0 { (r + inner) / 2.0 } else { r * 0.65 };
+            let (x, y) = polar(cx, cy, at, (a + b) / 2.0);
+            labels.push(DataLabel { x: x as f32, y: y as f32, text, inside: true });
+        }
         a = b;
     }
+    draw_data_labels(out, &labels, c.text_size, false);
+}
+
+/// The data label of point `i` of series `s`, when it shows one: the value as the file has it,
+/// in the series' number format.
+fn label_of(s: &Series, i: usize) -> Option<String> {
+    if s.labels != Some(true) {
+        return None;
+    }
+    let v = s.raw.get(i).copied().flatten()?;
+    let fmt = s.fmt.as_deref().filter(|f| !f.eq_ignore_ascii_case("General"));
+    Some(match fmt {
+        Some(f) => format_value(v, f, 1.0),
+        None => general_value(v),
+    })
+}
+
+/// A value in the `General` format: whole numbers without decimals, others with up to six.
+fn general_value(v: f64) -> String {
+    if v.fract() == 0.0 && v.abs() < 1e15 {
+        return format!("{v:.0}");
+    }
+    let s = format!("{v:.6}");
+    let s = s.trim_end_matches('0').trim_end_matches('.');
+    if s == "-0" { "0".to_string() } else { s.to_string() }
+}
+
+/// Data labels over the drawn chart. Beside labels sit above their point, or right of it for
+/// horizontal bars (`beside_right`).
+fn draw_data_labels(out: &mut Vec<GraphicItem>, labels: &[DataLabel], fs: f32, beside_right: bool) {
+    let lh = fs * LINE;
+    for l in labels {
+        let w = text_w(&l.text, fs) + 4.0;
+        let (rect, align) = if l.inside {
+            (Rect { x: l.x - w / 2.0, y: l.y - lh / 2.0, w, h: lh }, TextAlign::Center)
+        } else if beside_right {
+            (Rect { x: l.x + GAP / 2.0, y: l.y - lh / 2.0, w, h: lh }, TextAlign::Left)
+        } else {
+            (Rect { x: l.x - w / 2.0, y: l.y - lh, w, h: lh }, TextAlign::Center)
+        };
+        let color = if l.inside { Rgb::WHITE } else { TEXT };
+        out.push(GraphicItem::Text { rect: rect.arr(), text: l.text.clone(), size: fs, color, bold: false, align, font: None });
+    }
 }
 
 /// A point at clockwise angle `t` (radians from 12 o'clock) on a circle of radius `r`.
@@ -1607,6 +1714,26 @@ mod tests {
         assert!(items.iter().any(|it| matches!(it, GraphicItem::Text { text, .. } if text == "Q2")));
     }
 
+    #[test]
+    fn data_labels_show_the_values() {
+        let texts = |items: &[GraphicItem]| -> Vec<String> {
+            items.iter().filter_map(|it| if let GraphicItem::Text { text, .. } = it { Some(text.clone()) } else { None }).collect()
+        };
+        let labels = r#"<c:dLbls><c:showLegendKey val="0"/><c:showVal val="1"/></c:dLbls>"#;
+        let plot = format!(
+            r#"<c:barChart><c:barDir val="col"/><c:grouping val="clustered"/>{}{labels}<c:axId val="1"/><c:axId val="2"/></c:barChart><c:catAx><c:axId val="1"/></c:catAx><c:valAx><c:axId val="2"/></c:valAx>"#,
+            ser(0, "North", None, &["Q1", "Q2"], &["4.25", "17"]),
+        );
+        let shown = texts(&chart_items(&space(&plot), &theme(), 300.0, 200.0));
+        assert!(shown.contains(&"4.25".to_string()) && shown.contains(&"17".to_string()), "{shown:?}");
+        let pie = format!(r#"<c:pieChart><c:varyColors val="1"/>{}{labels}</c:pieChart>"#, ser(0, "S", None, &["A", "B"], &["1", "3"]));
+        let shown = texts(&chart_items(&space(&pie), &theme(), 200.0, 150.0));
+        assert!(shown.contains(&"3".to_string()), "{shown:?}");
+        // Without `c:dLbls`, no values are written next to the points.
+        let plain = plot.replace(labels, "");
+        assert!(!texts(&chart_items(&space(&plain), &theme(), 300.0, 200.0)).contains(&"4.25".to_string()));
+    }
+
     #[test]
     fn pie_draws_one_slice_per_point() {
         let plot =
diff --git a/crates/docx/src/read/diagram.rs b/crates/docx/src/read/diagram.rs
index c866574ce2..47ca458e0e 100644
--- a/crates/docx/src/read/diagram.rs
+++ b/crates/docx/src/read/diagram.rs
@@ -234,7 +234,9 @@ fn kind_of(prst: &str) -> Option<ShapeKind> {
         "ellipse" => ShapeKind::Ellipse,
         "triangle" => ShapeKind::Triangle,
         "diamond" => ShapeKind::Diamond,
-        "line" | "straightConnector1" => ShapeKind::Line,
+        // A line runs from its box's top-left to its bottom-right corner (a path; the Line shape
+        // kind draws the other diagonal).
+        "line" | "straightConnector1" => return None,
         "rightArrow" => ShapeKind::Arrow,
         "star5" | "star4" | "star6" => ShapeKind::Star,
         "heart" => ShapeKind::Heart,
@@ -466,9 +468,14 @@ fn text(sp: &El, xf: Xf, b: [f64; 4], theme: &[Rgb], filled: bool, fit: f32, out
     }
 }
 
+/// How wide `s` is at `size` points by the estimate chart and diagram text uses.
+pub(crate) fn text_width(s: &str, size: f32) -> f32 {
+    text_w(s, size)
+}
+
 /// Splits `text` into at most `max` lines of whole words that fit `width` points (by the shared
 /// text width estimate); a word wider than that keeps its own line.
-fn wrap(text: &str, size: f32, width: f32, max: usize) -> Vec<String> {
+pub(crate) fn wrap(text: &str, size: f32, width: f32, max: usize) -> Vec<String> {
     let limit = if width > 0.0 && size > 0.0 { width } else { f32::INFINITY };
     let space = text_w(" ", size);
     let mut lines = Vec::new();
@@ -521,6 +528,14 @@ impl Reader<'_> {
         rels.by_id(&id).is_some_and(|r| !r.external && rel_is(&r.kind, rt::DIAGRAM_DRAWING)).then_some(id)
     }
 
+    /// The SmartArt model of a diagram WordCraft wrote (its data part exactly as WordCraft writes
+    /// it); `None` for any other.
+    pub(super) fn smart_art_spec(&mut self, gd: &El, rels: &Rels) -> Option<wordcraft_doc::smart_art::SmartArtSpec> {
+        let dm = gd.child("dgm:relIds")?.attr("r:dm")?;
+        let data = super::part_of(rels, dm, rt::DIAGRAM_DATA)?;
+        crate::smart_art::spec_of(self.graphic_part(&data)?.as_ref())
+    }
+
     /// The items of the SmartArt drawing part at `path`, fitted to `w` × `h` points.
     pub(super) fn diagram_drawing(&mut self, path: &str, w: f32, h: f32) -> Vec<GraphicItem> {
         let Some(root) = self.graphic_part(path) else { return Vec::new() };
diff --git a/crates/docx/src/read/drawing_color.rs b/crates/docx/src/read/drawing_color.rs
index 60c73c33f8..4d2c7b9283 100644
--- a/crates/docx/src/read/drawing_color.rs
+++ b/crates/docx/src/read/drawing_color.rs
@@ -31,7 +31,7 @@ pub(crate) fn fill_colour(e: &El, theme: &[Rgb]) -> Option<Rgb> {
 }
 
 fn is_color(e: &El) -> bool {
-    matches!(e.name.as_str(), "a:srgbClr" | "a:schemeClr" | "a:sysClr")
+    matches!(e.name.as_str(), "a:srgbClr" | "a:schemeClr" | "a:sysClr" | "a:prstClr" | "a:scrgbClr" | "a:hslClr")
 }
 
 /// A colour element (`a:srgbClr`, `a:schemeClr`, `a:sysClr`), or the one inside `e`, with its
@@ -41,7 +41,25 @@ pub(crate) fn color(e: &El, theme: &[Rgb]) -> Option<Rgb> {
     let base = match c.name.as_str() {
         "a:srgbClr" => Rgb::parse(c.attr("val")?)?,
         "a:schemeClr" => *theme.get(scheme_slot(c.attr("val")?)?)?,
-        "a:sysClr" => Rgb::parse(c.attr("lastClr")?)?,
+        "a:sysClr" => match c.attr("lastClr").and_then(Rgb::parse) {
+            Some(rgb) => rgb,
+            None => sys_color(c.attr("val")?)?,
+        },
+        "a:prstClr" => preset_color(c.attr("val")?)?,
+        "a:scrgbClr" => {
+            // Linear 0–100 000 per channel, to sRGB.
+            let ch = |n: &str| -> u8 {
+                let l = c.attr(n).and_then(int).map_or(0.0, |v| (v as f64 / 100_000.0).clamp(0.0, 1.0));
+                let s = if l <= 0.003_130_8 { l * 12.92 } else { 1.055 * l.powf(1.0 / 2.4) - 0.055 };
+                (s * 255.0).round().clamp(0.0, 255.0) as u8
+            };
+            Rgb(ch("r"), ch("g"), ch("b"))
+        }
+        "a:hslClr" => {
+            let v = |n: &str| c.attr(n).and_then(int).unwrap_or(0) as f64;
+            let hue = (v("hue") / 60_000.0).rem_euclid(360.0) / 360.0;
+            from_hsl(hue, (v("sat") / 100_000.0).clamp(0.0, 1.0), (v("lum") / 100_000.0).clamp(0.0, 1.0))
+        }
         _ => return None,
     };
     let val = |m: &El| m.attr("val").and_then(int).map_or(0.0, |v| (v as f64 / 100_000.0).clamp(-10.0, 10.0));
@@ -58,6 +76,47 @@ pub(crate) fn color(e: &El, theme: &[Rgb]) -> Option<Rgb> {
     Some(rgb)
 }
 
+/// A preset colour (`a:prstClr/@val`, ECMA-376 Part 1 §20.1.10.48): the common ones; others are
+/// unknown (`None`).
+pub(crate) fn preset_color(name: &str) -> Option<Rgb> {
+    Some(match name {
+        "black" => Rgb(0, 0, 0),
+        "white" => Rgb(0xFF, 0xFF, 0xFF),
+        "red" => Rgb(0xFF, 0, 0),
+        "green" => Rgb(0, 0x80, 0),
+        "lime" => Rgb(0, 0xFF, 0),
+        "blue" => Rgb(0, 0, 0xFF),
+        "yellow" => Rgb(0xFF, 0xFF, 0),
+        "cyan" | "aqua" => Rgb(0, 0xFF, 0xFF),
+        "magenta" | "fuchsia" => Rgb(0xFF, 0, 0xFF),
+        "gray" | "grey" => Rgb(0x80, 0x80, 0x80),
+        "silver" => Rgb(0xC0, 0xC0, 0xC0),
+        "ltGray" | "ltGrey" => Rgb(0xD3, 0xD3, 0xD3),
+        "dkGray" | "dkGrey" => Rgb(0xA9, 0xA9, 0xA9),
+        "maroon" => Rgb(0x80, 0, 0),
+        "navy" => Rgb(0, 0, 0x80),
+        "olive" => Rgb(0x80, 0x80, 0),
+        "purple" => Rgb(0x80, 0, 0x80),
+        "teal" => Rgb(0, 0x80, 0x80),
+        "orange" => Rgb(0xFF, 0xA5, 0),
+        "brown" => Rgb(0xA5, 0x2A, 0x2A),
+        "pink" => Rgb(0xFF, 0xC0, 0xCB),
+        _ => return None,
+    })
+}
+
+/// A system colour without its `lastClr`: the usual light-theme values of the common ones.
+fn sys_color(name: &str) -> Option<Rgb> {
+    Some(match name {
+        "windowText" | "btnText" | "menuText" | "captionText" | "infoText" => Rgb(0, 0, 0),
+        "window" | "menu" | "highlightText" => Rgb(0xFF, 0xFF, 0xFF),
+        "btnFace" | "3dLight" => Rgb(0xF0, 0xF0, 0xF0),
+        "grayText" | "btnShadow" => Rgb(0xA0, 0xA0, 0xA0),
+        "highlight" => Rgb(0x00, 0x78, 0xD7),
+        _ => return None,
+    })
+}
+
 /// Index into `Document::settings.theme_colors` (dk1, lt1, dk2, lt2, accent1..6, hlink, folHlink).
 fn scheme_slot(name: &str) -> Option<usize> {
     Some(match name {
@@ -77,13 +136,24 @@ fn scheme_slot(name: &str) -> Option<usize> {
     })
 }
 
+/// Theme colour `name` (`accent1`, `tx1`…) of `theme`.
+pub(crate) fn scheme(name: &str, theme: &[Rgb]) -> Option<Rgb> {
+    scheme_slot(name).map(|i| slot(theme, i))
+}
+
+/// `c` with its luminance changed by `f`.
+pub(crate) fn lum(c: Rgb, f: impl Fn(f64) -> f64) -> Rgb {
+    adjust_lum(c, f)
+}
+
 /// `tint` (towards `to` = 255) and `shade` (towards 0): `v` is the share of the original colour kept.
 fn mix(c: Rgb, to: f64, v: f64) -> Rgb {
     let f = |x: u8| (x as f64 * v + to * (1.0 - v)).round().clamp(0.0, 255.0) as u8;
     Rgb(f(c.0), f(c.1), f(c.2))
 }
 
-fn adjust_lum(c: Rgb, f: impl Fn(f64) -> f64) -> Rgb {
+/// `c` with its HSL luminance changed by `f`.
+pub(crate) fn adjust_lum(c: Rgb, f: impl Fn(f64) -> f64) -> Rgb {
     let (h, s, l) = to_hsl(c);
     from_hsl(h, s, f(l).clamp(0.0, 1.0))
 }
diff --git a/crates/docx/src/read/embed.rs b/crates/docx/src/read/embed.rs
index 521660c4b8..e684dde0f8 100644
--- a/crates/docx/src/read/embed.rs
+++ b/crates/docx/src/read/embed.rs
@@ -13,13 +13,37 @@ use std::sync::Arc;
 use wordcraft_doc::graphic::{Embedded, EmbeddedRef};
 
 use super::Reader;
-use crate::package::{ContentTypes, MAX_EMBEDDED_PARTS, MAX_EMBEDDED_RELS, MAX_EMBEDDED_XML, Rel, Rels, manifest_field_ok};
+use crate::package::{
+    CUSTOM_XML_ROOTS, ContentTypes, MAX_EMBEDDED_PARTS, MAX_EMBEDDED_RELS, MAX_EMBEDDED_XML, Rel, Rels, manifest_field_ok, rel_is, rt,
+};
 use crate::xml::{El, MAX_DEPTH, NAMESPACES, esc};
 
 /// Most relationship ids one object's markup may use.
 const MAX_IDS: usize = 64;
 
 impl Reader<'_> {
+    /// Keep custom XML stores reached from the main document or package, without evaluating
+    /// bindings. A bibliography already loaded into the source model belongs to its writer.
+    pub(super) fn keep_custom_xml(&mut self, package: &Rels, document: &Rels) {
+        let mut roots = String::new();
+        for (owner, rels) in [("P", package), ("D", document)] {
+            for rel in rels.list.iter().filter(|r| !r.external && rel_is(&r.kind, rt::CUSTOM_XML)).take(MAX_EMBEDDED_RELS) {
+                if ![&rel.kind, &rel.target].iter().all(|s| manifest_field_ok(s)) {
+                    continue;
+                }
+                if !self.doc.sources.is_empty() && self.xml(&rel.target).ok().flatten().is_some_and(|r| r.local() == "Sources") {
+                    continue;
+                }
+                if self.keep_part_tree(&rel.target) {
+                    roots.push_str(&format!("{owner}\t{}\t{}\n", rel.kind, rel.target));
+                }
+            }
+        }
+        if !roots.is_empty() {
+            self.doc.passthrough.insert(CUSTOM_XML_ROOTS.into(), Arc::new(roots.into_bytes()));
+        }
+    }
+
     /// Keep `el` (an object's `a:graphic` or `w:object`, read with `rels`) and the parts it refers
     /// to, so the object can be written back. `extra` names relationships the object's parts use
     /// by id although its markup doesn't (a SmartArt drawing, named in the diagram's data part).
diff --git a/crates/docx/src/read/freeform.rs b/crates/docx/src/read/freeform.rs
index 50a6c775fd..6d2525f4d2 100644
--- a/crates/docx/src/read/freeform.rs
+++ b/crates/docx/src/read/freeform.rs
@@ -71,7 +71,7 @@ pub fn cust_geom(sppr: &El, w: f32, h: f32) -> Option<Freeform> {
             paths.push(FreePath { pts: pts.into_iter().take(MAX_POINTS).map(scale).collect(), closed: closed && !fill_none });
         }
     }
-    let f = Freeform { w, h, paths, alpha: 1.0, ink: None }.sanitized();
+    let f = Freeform { w, h, paths, alpha: 1.0, ink: None, order: None }.sanitized();
     (!f.paths.is_empty()).then_some(f)
 }
 
@@ -85,6 +85,12 @@ pub fn ink_tool(name: &str) -> Option<InkTool> {
     words.next().and_then(InkTool::parse)
 }
 
+/// The drawing order of an ink stroke written by WordCraft, from its drawing's name
+/// (`Ink Pen 3 #12`: the twelfth stroke drawn), for Ink Replay.
+pub fn ink_order(name: &str) -> Option<u32> {
+    name.split_whitespace().skip(3).find_map(|w| w.strip_prefix('#')?.parse().ok())
+}
+
 /// The outline opacity of `ln` (`a:ln`): its colour's `a:alpha`, 0–1.
 pub fn line_alpha(ln: Option<&El>) -> f32 {
     ln.and_then(|l| l.child("a:solidFill"))
diff --git a/crates/docx/src/read/mod.rs b/crates/docx/src/read/mod.rs
index 3cd99ecb7b..c86bb4fc76 100644
--- a/crates/docx/src/read/mod.rs
+++ b/crates/docx/src/read/mod.rs
@@ -1,13 +1,16 @@
 //! DOCX → [`Document`].
 
-mod chart;
-mod diagram;
+pub(crate) mod chart;
+pub(crate) mod diagram;
 mod drawing_color;
 mod embed;
 mod freeform;
 mod math;
 mod props;
+mod sdt;
+mod shape_style;
 mod story;
+mod wordart;
 
 use std::collections::{BTreeMap, HashMap, HashSet};
 use std::sync::Arc;
@@ -33,6 +36,22 @@ const MAX_PARTS: usize = 50_000;
 /// Most graphic work (items plus path segments, see `story::graphic_work`) built for one file's
 /// charts and diagrams; later ones are left empty.
 const MAX_GRAPHIC_WORK: usize = 2_000_000;
+/// Bibliography sources kept from a file (Word's own source manager holds far fewer).
+const MAX_SOURCES: usize = 10_000;
+/// Custom XML parts looked at for bibliography sources.
+const MAX_BIBLIOGRAPHY_PARTS: usize = 64;
+/// Characters kept of a bibliography's citation style name.
+const MAX_STYLE_NAME: usize = 64;
+
+/// Bibliography sources already read: tags, and (title, author) of untagged ones.
+#[derive(Default)]
+struct BibSeen {
+    tags: HashSet<String>,
+    untagged: HashSet<(String, String)>,
+}
+
+/// Longest attached-template path we keep (bytes); a longer one is not a real path.
+const MAX_TEMPLATE_PATH: usize = 32 * 1024;
 
 pub(crate) struct Reader<'p> {
     pkg: &'p Package,
@@ -54,12 +73,18 @@ pub(crate) struct Reader<'p> {
     pub comment_map: HashMap<String, u32>,
     pub comments_ended: HashSet<u32>,
     pub bookmarks: HashMap<String, String>,
+    /// Restrict Editing exception ranges (`w:permStart`): the file's id → ours.
+    pub perms: HashMap<String, u32>,
     /// Chart and diagram parts by path, parsed once.
     graphic_parts: HashMap<String, Option<Arc<El>>>,
     /// Charts and diagrams by (kind, part path, width bits, height bits), built once.
     graphics: HashMap<(GraphicKind, String, u32, u32), Arc<Graphic>>,
     /// Graphic work left before charts and diagrams are left empty (see [`MAX_GRAPHIC_WORK`]).
     graphic_budget: usize,
+    /// Drawing ids connectors are glued to (`a:stCxn`, `a:endCxn`), and whether any shape's id
+    /// was kept while reading (those not glued to are dropped at the end).
+    pub glued: HashSet<u32>,
+    pub shape_ids: bool,
     /// The main document part's name.
     main: String,
     /// The package's content types, read when first needed.
@@ -89,7 +114,12 @@ pub fn read(bytes: &[u8]) -> Result<Document, DocxError> {
 
 /// [`read`] for bytes known not to be an encrypted package.
 pub(crate) fn read_package(bytes: &[u8]) -> Result<Document, DocxError> {
-    let pkg = Package::open(bytes)?;
+    read_opened(&Package::open(bytes)?)
+}
+
+/// Read a package whose parts are already unpacked (from a zip, a Flat OPC file or a converted
+/// Word 2003 XML document).
+pub(crate) fn read_opened(pkg: &Package) -> Result<Document, DocxError> {
     let root_rels = pkg.rels("");
     let main = root_rels.by_type(rt::OFFICE_DOC).filter(|r| !r.external).map(|r| r.target.clone()).unwrap_or_else(|| "word/document.xml".to_string());
     let Some(root) = pkg.xml(&main)? else {
@@ -102,7 +132,7 @@ pub(crate) fn read_package(bytes: &[u8]) -> Result<Document, DocxError> {
     let mut doc = Document::new();
     doc.body.clear();
     let mut r = Reader {
-        pkg: &pkg,
+        pkg,
         doc,
         pc: PropCtx::default(),
         revs: HashMap::new(),
@@ -116,9 +146,12 @@ pub(crate) fn read_package(bytes: &[u8]) -> Result<Document, DocxError> {
         comment_map: HashMap::new(),
         comments_ended: HashSet::new(),
         bookmarks: HashMap::new(),
+        perms: HashMap::new(),
         graphic_parts: HashMap::new(),
         graphics: HashMap::new(),
         graphic_budget: MAX_GRAPHIC_WORK,
+        glued: HashSet::new(),
+        shape_ids: false,
         main: main.clone(),
         content_types: None,
         embedded: EmbeddedManifest::default(),
@@ -137,6 +170,10 @@ pub(crate) fn read_package(bytes: &[u8]) -> Result<Document, DocxError> {
             log::warn!("docx: ignoring unreadable {what}: {e}");
         }
     };
+    // Styles come before settings, but their theme colours already follow its colour mapping.
+    if let Some(p) = part(rt::SETTINGS) {
+        r.read_color_mapping(&p);
+    }
     if let Some(p) = part(rt::STYLES) {
         lenient("styles", r.read_styles(&p));
     }
@@ -158,6 +195,31 @@ pub(crate) fn read_package(bytes: &[u8]) -> Result<Document, DocxError> {
         let ex = part(rt::COMMENTS_EX);
         lenient("comments", r.read_comments(&p, ex.as_deref()));
     }
+    // Bibliography sources live in a custom XML data store (`b:Sources`), related from the
+    // package root or the main part; Word's own files sometimes leave the relationship out, so
+    // the conventional `customXml/itemN.xml` names are tried too. Each part is read at most once.
+    let mut bib_parts: Vec<String> = Vec::new();
+    for rel in root_rels.list.iter().chain(rels.list.iter()) {
+        if rel_is(&rel.kind, rt::CUSTOM_XML) && !rel.external && !bib_parts.contains(&rel.target) {
+            bib_parts.push(rel.target.clone());
+            if bib_parts.len() >= MAX_BIBLIOGRAPHY_PARTS {
+                break;
+            }
+        }
+    }
+    for i in 1..=16 {
+        let path = format!("customXml/item{i}.xml");
+        if bib_parts.len() < MAX_BIBLIOGRAPHY_PARTS && pkg.get(&path).is_some() && !bib_parts.contains(&path) {
+            bib_parts.push(path);
+        }
+    }
+    let mut seen_sources = BibSeen::default();
+    for path in &bib_parts {
+        if r.doc.sources.len() >= MAX_SOURCES {
+            break;
+        }
+        lenient("customXml bibliography", r.read_bibliography(path, &mut seen_sources));
+    }
 
     if let Some(bg) = root.child("w:background").and_then(|b| b.attr("w:color")).and_then(Rgb::parse) {
         r.doc.settings.page_color = Some(bg);
@@ -190,6 +252,7 @@ pub(crate) fn read_package(bytes: &[u8]) -> Result<Document, DocxError> {
         r.doc.passthrough.insert(VBA_PROJECT_PART.into(), Arc::new(b.to_vec()));
         r.read_vba_related(&v);
     }
+    r.keep_custom_xml(&root_rels, &rels);
     if !r.embedded.parts.is_empty() {
         let manifest = r.embedded.to_bytes();
         r.doc.passthrough.insert(EMBEDDED_PARTS.into(), Arc::new(manifest));
@@ -197,6 +260,9 @@ pub(crate) fn read_package(bytes: &[u8]) -> Result<Document, DocxError> {
     r.finish_moves();
     let links = std::mem::take(&mut r.txbx_links);
     link_text_boxes(&mut r.doc, links);
+    if r.shape_ids {
+        keep_glued_ids(&mut r.doc, &r.glued);
+    }
     let mut doc = r.doc;
     doc.ensure_nonempty();
     Ok(doc)
@@ -298,6 +364,27 @@ fn link_text_boxes(doc: &mut Document, mut links: Vec<(u32, u32, u32)>) {
     }
 }
 
+/// Drop the drawing ids read with shapes, except those connectors are glued to (so a shape
+/// without connectors reads back as it was written).
+fn keep_glued_ids(doc: &mut Document, glued: &HashSet<u32>) {
+    let has_id = |o: &InlineObject| match o {
+        InlineObject::Shape { extra, .. } => extra.id != 0,
+        InlineObject::Group { children, .. } => children.iter().any(|c| matches!(&c.obj, InlineObject::Shape { extra, .. } if extra.id != 0)),
+        _ => false,
+    };
+    let clear = |o: &mut InlineObject| {
+        if let InlineObject::Shape { extra, .. } = o
+            && !glued.contains(&extra.id)
+        {
+            extra.id = 0;
+        }
+    };
+    doc.objects_mut(&has_id, &mut |o| match o {
+        InlineObject::Group { children, .. } => children.iter_mut().for_each(|c| clear(&mut c.obj)),
+        o => clear(o),
+    });
+}
+
 /// Word starts a TOC field in the first entry; the engine keeps it at the end of the TOC heading
 /// (the paragraph holding the field marks where the TOC is). Move it there when one precedes it.
 fn toc_field_to_heading(body: &mut Blocks) {
@@ -523,6 +610,7 @@ impl Reader<'_> {
                     *slot = rgb;
                 }
             }
+            self.pc.theme_colors = colors.clone();
             self.doc.settings.theme_colors = colors;
         }
         if let Some(fs) = el.child("a:fontScheme") {
@@ -537,6 +625,48 @@ impl Reader<'_> {
         }
         self.pc.major_font = self.doc.settings.major_font.clone();
         self.pc.minor_font = self.doc.settings.minor_font.clone();
+        self.pc.theme = self.doc.settings.theme_colors.clone();
+    }
+
+    /// `w:settings/w:clrSchemeMapping`: which scheme colour text1, background1… stand for.
+    fn read_color_mapping(&mut self, path: &str) {
+        let Ok(Some(root)) = self.xml(path) else { return };
+        let Some(m) = root.child("w:clrSchemeMapping") else { return };
+        let names = [
+            "dark1",
+            "light1",
+            "dark2",
+            "light2",
+            "accent1",
+            "accent2",
+            "accent3",
+            "accent4",
+            "accent5",
+            "accent6",
+            "hyperlink",
+            "followedHyperlink",
+        ];
+        let attrs = [
+            "w:t1",
+            "w:bg1",
+            "w:t2",
+            "w:bg2",
+            "w:accent1",
+            "w:accent2",
+            "w:accent3",
+            "w:accent4",
+            "w:accent5",
+            "w:accent6",
+            "w:hyperlink",
+            "w:followedHyperlink",
+        ];
+        let mut map = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+        for (slot, a) in map.iter_mut().zip(attrs) {
+            if let Some(i) = m.attr(a).and_then(|v| names.iter().position(|n| *n == v)) {
+                *slot = i;
+            }
+        }
+        self.pc.color_map = Some(map);
     }
 
     fn read_styles(&mut self, path: &str) -> Result<(), DocxError> {
@@ -552,6 +682,7 @@ impl Reader<'_> {
             self.pc.alias.insert(id.to_string(), "Normal".into());
         }
         let mut sheet = StyleSheet::empty();
+        sheet.default_para_present = root.child("w:docDefaults").and_then(|dd| dd.child("w:pPrDefault")).is_some();
         if let Some(dd) = root.child("w:docDefaults") {
             if let Some(r) = dd.child("w:rPrDefault").and_then(|d| d.child("w:rPr")) {
                 sheet.default_chr = self.pc.rpr(r);
@@ -588,6 +719,7 @@ impl Reader<'_> {
                 quick: flag(s, "w:qFormat").unwrap_or(false),
                 hidden: flag(s, "w:semiHidden").unwrap_or(false) || flag(s, "w:hidden").unwrap_or(false),
                 builtin: !s.attr("w:customStyle").is_some_and(|v| v == "1" || v == "true"),
+                locked: flag(s, "w:locked").unwrap_or(false),
                 ..Default::default()
             };
             if let Some(p) = s.child("w:pPr") {
@@ -614,12 +746,12 @@ impl Reader<'_> {
             if let Some(b) = tp.child("w:tblBorders") {
                 t.borders = Some(props::borders(b));
             }
-            t.fill = tp.child("w:shd").and_then(props::shd_fill);
+            t.fill = tp.child("w:shd").and_then(|e| self.pc.shd_fill(e));
             t.cell_margins = tp.child("w:tblCellMar").map(props::margins);
             t.band_size = tp.child_val("w:tblStyleRowBandSize").and_then(u32_of).filter(|n| *n > 0).map(|n| n.min(1000));
         }
         for c in s.children("w:tblStylePr").take(64) {
-            let fill = c.child("w:tcPr").and_then(|p| p.child("w:shd")).and_then(props::shd_fill);
+            let fill = c.child("w:tcPr").and_then(|p| p.child("w:shd")).and_then(|e| self.pc.shd_fill(e));
             let cell_borders = c.child("w:tcPr").and_then(|p| p.child("w:tcBorders")).map(props::borders);
             let chr = c.child("w:rPr").map(|r| self.pc.rpr(r)).unwrap_or_default();
             match c.attr("w:type") {
@@ -772,9 +904,19 @@ impl Reader<'_> {
 
     fn read_settings(&mut self, path: &str) -> Result<(), DocxError> {
         let Some(root) = self.xml(path)? else { return Ok(()) };
+        let rels = self.pkg.rels(path);
         let s = &mut self.doc.settings;
         for k in root.els() {
             match k.name.as_str() {
+                // §17.15.1.6: the template, by a relationship (usually external) of the settings part.
+                "w:attachedTemplate" => {
+                    s.attached_template = k
+                        .attr("r:id")
+                        .and_then(|id| rels.by_id(id))
+                        .map(|r| r.target.trim().to_string())
+                        .filter(|t| !t.is_empty() && t.len() <= MAX_TEMPLATE_PATH);
+                }
+                "w:linkStyles" => s.link_styles = on_off(k),
                 "w:compat" => {
                     // Only Word's own setting: another `w:uri` names a different application's.
                     let mode = k
@@ -804,6 +946,17 @@ impl Reader<'_> {
                 "m:mathPr" => s.math = Some(math::read_math_pr(k)),
                 "w:mirrorMargins" => s.mirror_margins = on_off(k),
                 "w:autoHyphenation" => s.auto_hyphenation = on_off(k),
+                "w:doNotHyphenateCaps" => s.hyphenate_caps = !on_off(k),
+                "w:hyphenationZone" => {
+                    if let Some(v) = tw(k, "w:val").filter(|v| v.is_finite() && *v >= 0.0) {
+                        s.hyphenation_zone = v.min(1584.0);
+                    }
+                }
+                "w:consecutiveHyphenLimit" => {
+                    if let Some(v) = k.attr("w:val").and_then(u32_of) {
+                        s.consecutive_hyphen_limit = v.min(32_767);
+                    }
+                }
                 "w:footnotePr" => {
                     if let Some(f) = k.child_val("w:numFmt") {
                         s.footnote_format = NumFormat::from_ooxml(f);
@@ -816,12 +969,7 @@ impl Reader<'_> {
                     }
                     s.endnote_pr = props::note_pr(k, false);
                 }
-                "w:documentProtection" => {
-                    let enforced = k.attr("w:enforcement").is_some_and(|v| !matches!(v, "0" | "false" | "off"));
-                    if enforced && let Some(e) = k.attr("w:edit") {
-                        s.protection = Some(e.to_string());
-                    }
-                }
+                "w:documentProtection" => read_protection(k, s),
                 _ => {}
             }
         }
@@ -959,6 +1107,130 @@ impl Reader<'_> {
         Ok(())
     }
 
+    /// Sources from a `b:Sources` custom XML part (other custom XML is left alone); at most
+    /// [`MAX_SOURCES`] in all, and the document's citation style from `StyleName`.
+    fn read_bibliography(&mut self, path: &str, seen: &mut BibSeen) -> Result<(), DocxError> {
+        let Some(root) = self.xml(path)? else { return Ok(()) };
+        if root.local() != "Sources" {
+            return Ok(());
+        }
+        if self.doc.settings.bib_style.is_none()
+            && let Some(name) = root.attrs.iter().find(|(k, _)| k.rsplit(':').next() == Some("StyleName")).map(|(_, v)| v.trim())
+            && !name.is_empty()
+        {
+            self.doc.settings.bib_style = Some(name.chars().take(MAX_STYLE_NAME).collect());
+        }
+        let child_text = |el: &El, local: &str| el.els().find(|e| e.local() == local).map(|e| e.text()).unwrap_or_default();
+        let parse_persons = |parent: &El| -> String {
+            let mut names = Vec::new();
+            let person_els: Vec<&El> = {
+                let in_lists: Vec<&El> =
+                    parent.els().filter(|e| e.local() == "NameList").flat_map(|n| n.els().filter(|e| e.local() == "Person")).collect();
+                if in_lists.is_empty() { parent.els().filter(|e| e.local() == "Person").collect() } else { in_lists }
+            };
+            for name_el in person_els {
+                let last = child_text(name_el, "Last");
+                let first = child_text(name_el, "First");
+                let middle = child_text(name_el, "Middle");
+                let name = if !first.is_empty() && !middle.is_empty() {
+                    format!("{last}, {first} {middle}")
+                } else if !first.is_empty() {
+                    format!("{last}, {first}")
+                } else {
+                    last
+                };
+                if !name.is_empty() {
+                    names.push(name);
+                }
+            }
+            names.join("; ")
+        };
+
+        for src_el in root.els().filter(|e| e.local() == "Source") {
+            if self.doc.sources.len() >= MAX_SOURCES {
+                log::warn!("docx: more than {MAX_SOURCES} bibliography sources; the rest are dropped");
+                break;
+            }
+            let tag = child_text(src_el, "Tag");
+            let raw_kind = child_text(src_el, "SourceType");
+            let kind = crate::write::from_source_type(&raw_kind);
+            let (author, editor) = match src_el.els().find(|e| e.local() == "Author") {
+                Some(a) => {
+                    let auth =
+                        a.els().find(|e| e.local() == "Author").map(parse_persons).filter(|s| !s.is_empty()).unwrap_or_else(|| parse_persons(a));
+                    let ed = a.els().find(|e| e.local() == "Editor").map(parse_persons).unwrap_or_default();
+                    (auth, ed)
+                }
+                None => (String::new(), String::new()),
+            };
+            let editor = if editor.is_empty() { src_el.els().find(|e| e.local() == "Editor").map(parse_persons).unwrap_or_default() } else { editor };
+            let title = child_text(src_el, "Title");
+            let year = child_text(src_el, "Year");
+            let month = child_text(src_el, "Month");
+            let day = child_text(src_el, "Day");
+            let city = child_text(src_el, "City");
+            let publisher = child_text(src_el, "Publisher");
+            let journal = child_text(src_el, "JournalName");
+            let edition = child_text(src_el, "Edition");
+            let volume = child_text(src_el, "Volume");
+            let issue = child_text(src_el, "Issue");
+            let pages = child_text(src_el, "Pages");
+            let url = child_text(src_el, "URL");
+            let accessed = match child_text(src_el, "Accessed") {
+                a if !a.is_empty() => a,
+                _ => {
+                    let y = child_text(src_el, "YearAccessed");
+                    let m = child_text(src_el, "MonthAccessed");
+                    let d = child_text(src_el, "DayAccessed");
+                    if !y.is_empty() && !m.is_empty() && !d.is_empty() {
+                        format!("{y}-{m}-{d}")
+                    } else if !y.is_empty() && !m.is_empty() {
+                        format!("{y}-{m}")
+                    } else {
+                        y
+                    }
+                }
+            };
+            let doi = match child_text(src_el, "DOI") {
+                d if !d.is_empty() => d,
+                _ => child_text(src_el, "StandardNumber"),
+            };
+
+            // Keep sources with some content, once each (by tag, or title and author untagged).
+            if tag.is_empty() && title.is_empty() && author.is_empty() && editor.is_empty() {
+                continue;
+            }
+            let fresh = if tag.is_empty() {
+                seen.untagged.insert((title.clone(), if author.is_empty() { editor.clone() } else { author.clone() }))
+            } else {
+                seen.tags.insert(tag.clone())
+            };
+            if fresh {
+                self.doc.sources.push(wordcraft_doc::Source {
+                    tag,
+                    kind,
+                    author,
+                    title,
+                    year,
+                    city,
+                    publisher,
+                    journal,
+                    volume,
+                    pages,
+                    url,
+                    editor,
+                    edition,
+                    issue,
+                    month,
+                    day,
+                    accessed,
+                    doi,
+                });
+            }
+        }
+        Ok(())
+    }
+
     fn read_core(&mut self, path: &str) {
         let Ok(Some(root)) = self.xml(path) else { return };
         let c = &mut self.doc.core;
@@ -981,6 +1253,51 @@ impl Reader<'_> {
     }
 }
 
-fn default_level(i: usize) -> Level {
-    Level { indent: 36.0 * (i as f32 + 1.0), text: String::new(), ..Level::default() }
+/// A level as the file defines it before its own elements: no indents (a level without `w:ind`
+/// leaves the label at the paragraph's left edge, as Word shows it), no text.
+fn default_level(_i: usize) -> Level {
+    Level { indent: 0.0, hanging: 0.0, text: String::new(), ..Level::default() }
+}
+
+/// The password hash attributes of `w:documentProtection` that are kept (ECMA-376 §17.15.1.29:
+/// the current `algorithmName`/`hashValue`/`saltValue`/`spinCount`, and the older transitional
+/// `crypt*`/`hash`/`salt` set).
+pub(crate) const PROTECTION_HASH_ATTRS: [&str; 16] = [
+    "w:algorithmName",
+    "w:hashValue",
+    "w:saltValue",
+    "w:spinCount",
+    "w:cryptProviderType",
+    "w:cryptAlgorithmClass",
+    "w:cryptAlgorithmType",
+    "w:cryptAlgorithmSid",
+    "w:cryptSpinCount",
+    "w:cryptProvider",
+    "w:algIdExt",
+    "w:algIdExtSource",
+    "w:cryptProviderTypeExt",
+    "w:cryptProviderTypeExtSource",
+    "w:hash",
+    "w:salt",
+];
+
+/// Restrict Editing (`w:documentProtection`, §17.15.1.29): the editing restriction, whether
+/// formatting is limited to unlocked styles, and the password hash. Only enforced protection is
+/// kept; a hostile attribute value can't be longer than a hash needs.
+fn read_protection(k: &El, s: &mut wordcraft_doc::Settings) {
+    let on = |v: &str| !matches!(v, "0" | "false" | "off");
+    if !k.attr("w:enforcement").is_some_and(on) {
+        return;
+    }
+    let edit = k.attr("w:edit").filter(|e| matches!(*e, "readOnly" | "comments" | "trackedChanges" | "forms"));
+    let formatting = k.attr("w:formatting").is_some_and(on);
+    if edit.is_none() && !formatting {
+        return;
+    }
+    s.protection = Some(edit.unwrap_or("none").to_string());
+    s.protect_formatting = formatting;
+    s.protect_hash = PROTECTION_HASH_ATTRS
+        .iter()
+        .filter_map(|n| k.attr(n).filter(|v| !v.is_empty() && v.len() <= 1024).map(|v| (n.to_string(), v.to_string())))
+        .collect();
 }
diff --git a/crates/docx/src/read/props.rs b/crates/docx/src/read/props.rs
index d423107747..7a307db3a6 100644
--- a/crates/docx/src/read/props.rs
+++ b/crates/docx/src/read/props.rs
@@ -2,6 +2,7 @@
 
 use std::collections::HashMap;
 
+use wordcraft_doc::para::cap_alt;
 use wordcraft_doc::props::{
     Align, Border, BorderStyle, Borders, CellProps, CharProps, HeightRule, Highlight, LineSpacing, NumRef, ParaProps, Rgb, RowProps, TabAlign,
     TabLeader, TabStop, TableFloat, TableLook, TableProps, TextColor, TextDirection, Underline, VAlign, VMerge, VertAlign,
@@ -11,16 +12,25 @@ use wordcraft_doc::section::{
     SectionProps, SectionStart,
 };
 
+use super::drawing_color::adjust_lum;
 use crate::units::{int, measure, on_off, tw, u32_of};
 use crate::xml::El;
 
-/// Context for property reading: theme fonts and style id aliases.
+/// Context for property reading: theme fonts and colours, and style id aliases.
 #[derive(Default)]
 pub struct PropCtx {
     pub major_font: String,
     pub minor_font: String,
+    /// The theme's colour scheme (dk1, lt1, dk2, lt2, accent1..6, hlink, folHlink); empty when the
+    /// package has none, and then `w:themeColor` falls back to the fixed colour.
+    pub theme_colors: Vec<Rgb>,
+    /// `w:clrSchemeMapping`: the scheme slot each of text1, background1, text2, background2,
+    /// accent1..6, hyperlink and followedHyperlink uses. `None` = the default (same order).
+    pub color_map: Option<[usize; 12]>,
     /// Style id renames (e.g. a localized default paragraph style id → `Normal`).
     pub alias: HashMap<String, String>,
+    /// The theme's colours (for WordArt effects in theme colours).
+    pub theme: Vec<Rgb>,
 }
 
 impl PropCtx {
@@ -33,34 +43,88 @@ impl PropCtx {
         (!f.is_empty()).then(|| f.clone())
     }
 
+    /// The theme colour `e` names in `attr` (`w:themeColor`, `w:themeFill`), through the colour
+    /// scheme mapping, with its `tint` and `shade` (hex bytes) applied to the HSL luminance as
+    /// Word does. When given it supersedes the fixed colour; `None` leaves the fixed one.
+    fn theme_color(&self, e: &El, attr: &str, tint: &str, shade: &str) -> Option<Rgb> {
+        let logical = |i: usize| self.color_map.and_then(|m| m.get(i).copied()).unwrap_or(i);
+        let slot = match e.attr(attr)? {
+            "dark1" => 0,
+            "light1" => 1,
+            "dark2" => 2,
+            "light2" => 3,
+            "text1" => logical(0),
+            "background1" => logical(1),
+            "text2" => logical(2),
+            "background2" => logical(3),
+            "accent1" => logical(4),
+            "accent2" => logical(5),
+            "accent3" => logical(6),
+            "accent4" => logical(7),
+            "accent5" => logical(8),
+            "accent6" => logical(9),
+            "hyperlink" => logical(10),
+            "followedHyperlink" => logical(11),
+            _ => return None,
+        };
+        let mut c = *self.theme_colors.get(slot)?;
+        let byte = |a: &str| e.attr(a).and_then(|v| u8::from_str_radix(v.trim(), 16).ok()).map(|v| f64::from(v) / 255.0);
+        if let Some(t) = byte(tint) {
+            c = adjust_lum(c, |l| l * t + (1.0 - t));
+        }
+        if let Some(s) = byte(shade) {
+            c = adjust_lum(c, |l| l * s);
+        }
+        Some(c)
+    }
+
+    /// `w:shd`: its fill colour (a theme fill first), or a solid pattern's colour.
+    pub fn shd_fill(&self, e: &El) -> Option<Rgb> {
+        if let Some(c) = self.theme_color(e, "w:themeFill", "w:themeFillTint", "w:themeFillShade") {
+            return Some(c);
+        }
+        // A solid pattern without a fill is painted in its pattern colour, a theme one first.
+        if e.attr("w:val") == Some("solid")
+            && e.attr("w:fill").and_then(Rgb::parse).is_none()
+            && let Some(c) = self.theme_color(e, "w:themeColor", "w:themeTint", "w:themeShade")
+        {
+            return Some(c);
+        }
+        shd_fill(e)
+    }
+
     pub fn rpr(&self, e: &El) -> CharProps {
         let mut c = CharProps::default();
         for k in e.els() {
             match k.name.as_str() {
                 "w:rStyle" => c.style = k.attr("w:val").filter(|v| !v.is_empty()).map(|v| self.style_id(v)),
                 "w:rFonts" => {
-                    c.font = k
-                        .attr("w:ascii")
-                        .or_else(|| k.attr("w:hAnsi"))
-                        .filter(|f| !f.is_empty())
-                        .map(str::to_string)
-                        .or_else(|| k.attr("w:asciiTheme").or_else(|| k.attr("w:hAnsiTheme")).and_then(|t| self.theme_font(t)))
-                        .or_else(|| {
-                            // `w:eastAsia` and `w:cs` name fonts for other scripts; they stand in for the
-                            // Latin font only when the run is hinted as that script. Otherwise the Latin
-                            // font is inherited (a Normal style with only `w:eastAsia`/`w:cs` keeps the
-                            // `docDefaults` font, as in Word).
-                            match k.attr("w:hint") {
-                                Some("eastAsia") => k.attr("w:eastAsia"),
-                                Some("cs") => k.attr("w:cs"),
-                                _ => None,
-                            }
-                            .filter(|f| !f.is_empty())
-                            .map(str::to_string)
-                        });
+                    // A theme font supersedes the fixed font beside it (`w:asciiTheme` over
+                    // `w:ascii`, `w:hAnsiTheme` over `w:hAnsi`).
+                    let named = |a: &str| k.attr(a).filter(|f| !f.is_empty()).map(str::to_string);
+                    let themed = |a: &str| k.attr(a).and_then(|t| self.theme_font(t));
+                    c.font =
+                        themed("w:asciiTheme").or_else(|| named("w:ascii")).or_else(|| themed("w:hAnsiTheme")).or_else(|| named("w:hAnsi")).or_else(
+                            || {
+                                // `w:eastAsia` and `w:cs` name fonts for other scripts; they stand in for the
+                                // Latin font only when the run is hinted as that script. Otherwise the Latin
+                                // font is inherited (a Normal style with only `w:eastAsia`/`w:cs` keeps the
+                                // `docDefaults` font, as in Word).
+                                match k.attr("w:hint") {
+                                    Some("eastAsia") => k.attr("w:eastAsia"),
+                                    Some("cs") => k.attr("w:cs"),
+                                    _ => None,
+                                }
+                                .filter(|f| !f.is_empty())
+                                .map(str::to_string)
+                            },
+                        );
                     // The complex-script font (Persian, Arabic, Hebrew text). A `w:cstheme` font is
                     // left to inherit: the theme's per-script fonts aren't read.
                     c.font_cs = k.attr("w:cs").filter(|f| !f.is_empty() && f.len() < 256).map(str::to_string);
+                    // The East Asian font (Chinese, Japanese, Korean text). A `w:eastAsiaTheme` font
+                    // is left to inherit, like `w:cstheme`.
+                    c.font_ea = k.attr("w:eastAsia").filter(|f| !f.is_empty() && f.len() < 256).map(str::to_string);
                 }
                 "w:b" => c.bold = Some(on_off(k)),
                 "w:bCs" => c.bold_cs = Some(on_off(k)),
@@ -79,10 +143,11 @@ impl PropCtx {
                 "w:vanish" => c.hidden = Some(on_off(k)),
                 "w:rtl" => c.rtl = Some(on_off(k)),
                 "w:color" => {
-                    c.color = match k.attr("w:val") {
-                        Some(v) if v.eq_ignore_ascii_case("auto") => Some(TextColor::Auto),
-                        Some(v) => Rgb::parse(v).map(TextColor::Rgb),
-                        None => None,
+                    c.color = match (self.theme_color(k, "w:themeColor", "w:themeTint", "w:themeShade"), k.attr("w:val")) {
+                        (Some(t), _) => Some(TextColor::Rgb(t)),
+                        (None, Some(v)) if v.eq_ignore_ascii_case("auto") => Some(TextColor::Auto),
+                        (None, Some(v)) => Rgb::parse(v).map(TextColor::Rgb),
+                        (None, None) => None,
                     }
                 }
                 "w:spacing" => c.spacing = tw(k, "w:val").map(|v| v.clamp(-1584.0, 1584.0)),
@@ -98,10 +163,11 @@ impl PropCtx {
                     } else {
                         c.underline = Some(Underline::Single);
                     }
-                    c.underline_color = k.attr("w:color").and_then(Rgb::parse);
+                    c.underline_color =
+                        self.theme_color(k, "w:themeColor", "w:themeTint", "w:themeShade").or_else(|| k.attr("w:color").and_then(Rgb::parse));
                 }
                 "w:bdr" => c.border = Some(border(k)),
-                "w:shd" => c.shading = shd_fill(k),
+                "w:shd" => c.shading = self.shd_fill(k),
                 "w:vertAlign" => {
                     c.vert_align = k.attr("w:val").map(|v| match v {
                         "superscript" => VertAlign::Superscript,
@@ -113,6 +179,13 @@ impl PropCtx {
                     c.lang = k.attr("w:val").filter(|v| !v.is_empty() && v.len() < 64).map(str::to_string);
                     c.lang_bidi = k.attr("w:bidi").filter(|v| !v.is_empty() && v.len() < 64).map(str::to_string);
                 }
+                n if n.starts_with("w14:") => {
+                    let fx = c.text_effects.get_or_insert_with(Default::default);
+                    super::wordart::read(k, &self.theme, fx);
+                    if fx.is_empty() {
+                        c.text_effects = None;
+                    }
+                }
                 _ => {}
             }
         }
@@ -142,6 +215,7 @@ impl PropCtx {
                 "w:pageBreakBefore" => p.page_break_before = Some(on_off(k)),
                 "w:widowControl" => p.widow_control = Some(on_off(k)),
                 "w:contextualSpacing" => p.contextual_spacing = Some(on_off(k)),
+                "w:mirrorIndents" => p.mirror_indents = Some(on_off(k)),
                 "w:suppressAutoHyphens" => p.suppress_hyphens = Some(on_off(k)),
                 "w:suppressLineNumbers" => p.suppress_line_numbers = Some(on_off(k)),
                 "w:bidi" => p.bidi = Some(on_off(k)),
@@ -165,7 +239,7 @@ impl PropCtx {
                     }
                 }
                 "w:pBdr" => p.borders = Some(borders(k)),
-                "w:shd" => p.shading = shd_fill(k),
+                "w:shd" => p.shading = self.shd_fill(k),
                 "w:tabs" => {
                     let tabs: Vec<TabStop> = k.children("w:tab").take(64).filter_map(tab_stop).collect();
                     p.tabs = Some(tabs);
@@ -199,6 +273,19 @@ impl PropCtx {
                     } else if let Some(v) = tw(k, "w:firstLine") {
                         p.indent_first = Some(v);
                     }
+                    // Character units (hundredths of a character), which win when non-zero.
+                    let chars = |a: &str| k.attr(a).and_then(int).map(|v| v.clamp(-158_400, 158_400) as f32 / 100.0);
+                    if let Some(v) = chars("w:leftChars").or_else(|| chars("w:startChars")) {
+                        p.indent_left_chars = Some(v);
+                    }
+                    if let Some(v) = chars("w:rightChars").or_else(|| chars("w:endChars")) {
+                        p.indent_right_chars = Some(v);
+                    }
+                    match (chars("w:hangingChars"), chars("w:firstLineChars")) {
+                        (Some(h), f) if h != 0.0 || f.is_none() => p.indent_first_chars = Some(-h),
+                        (_, Some(f)) => p.indent_first_chars = Some(f),
+                        _ => {}
+                    }
                 }
                 "w:jc" => p.align = k.attr("w:val").map(align),
                 "w:outlineLvl" => p.outline_level = k.attr("w:val").and_then(u32_of).map(|v| v.min(9) as u8),
@@ -240,8 +327,8 @@ fn tab_stop(t: &El) -> Option<TabStop> {
     Some(TabStop { pos, align, leader })
 }
 
-/// `w:shd/@w:fill` (a solid fill colour; `auto` = none).
-pub fn shd_fill(e: &El) -> Option<Rgb> {
+/// `w:shd/@w:fill` (a solid fill colour; `auto` = none), ignoring theme fills ([`PropCtx::shd_fill`]).
+fn shd_fill(e: &El) -> Option<Rgb> {
     let fill = e.attr("w:fill").and_then(Rgb::parse);
     if fill.is_some() {
         return fill;
@@ -306,7 +393,7 @@ impl PropCtx {
                 "w:jc" => t.align = k.attr("w:val").map(align),
                 "w:tblInd" => t.indent = tw(k, "w:w"),
                 "w:tblBorders" => t.borders = Some(borders(k)),
-                "w:shd" => t.shading = shd_fill(k),
+                "w:shd" => t.shading = self.shd_fill(k),
                 "w:tblLayout" => t.fixed = k.attr("w:type") == Some("fixed"),
                 "w:bidiVisual" => t.bidi_visual = on_off(k),
                 "w:tblCellMar" => t.cell_margins = Some(margins(k)),
@@ -317,8 +404,8 @@ impl PropCtx {
                         f.overlap = k.attr("w:val") != Some("never");
                     }
                 }
-                "w:tblCaption" => t.caption = k.attr("w:val").map(str::to_string),
-                "w:tblDescription" if t.caption.is_none() => t.caption = k.attr("w:val").map(str::to_string),
+                "w:tblCaption" => t.caption = k.attr("w:val").map(cap_alt),
+                "w:tblDescription" => t.description = k.attr("w:val").map(cap_alt),
                 _ => {}
             }
         }
@@ -381,7 +468,7 @@ pub fn trpr(e: &El) -> RowProps {
 }
 
 /// `w:tcPr`; returns the props and whether the cell is a legacy `hMerge` continuation.
-pub fn tcpr(e: &El) -> (CellProps, bool) {
+pub fn tcpr(pc: &PropCtx, e: &El) -> (CellProps, bool) {
     let mut c = CellProps { span: 1, ..Default::default() };
     let mut hcont = false;
     for k in e.els() {
@@ -400,7 +487,7 @@ pub fn tcpr(e: &El) -> (CellProps, bool) {
             "w:hMerge" => hcont = k.attr("w:val") != Some("restart"),
             "w:vMerge" => c.vmerge = if k.attr("w:val") == Some("restart") { VMerge::Restart } else { VMerge::Continue },
             "w:tcBorders" => c.borders = Some(borders(k)),
-            "w:shd" => c.shading = shd_fill(k),
+            "w:shd" => c.shading = pc.shd_fill(k),
             "w:noWrap" => c.no_wrap = on_off(k),
             "w:tcMar" => c.margins = Some(margins(k)),
             "w:textDirection" => c.text_direction = TextDirection::from_ooxml(k.attr("w:val").unwrap_or("")),
@@ -494,6 +581,7 @@ pub fn sectpr(e: &El) -> (SectionProps, Vec<HfRef>) {
             "w:endnotePr" => s.endnote_pr = note_pr(k, true),
             "w:titlePg" => s.title_page = on_off(k),
             "w:bidi" => s.rtl = on_off(k),
+            "w:textDirection" => s.text_direction = wordcraft_doc::props::TextDirection::from_ooxml(k.attr("w:val").unwrap_or("")),
             "w:pgNumType" => {
                 s.page_num_start = k.attr("w:start").and_then(u32_of);
                 if let Some(f) = k.attr("w:fmt") {
diff --git a/crates/docx/src/read/sdt.rs b/crates/docx/src/read/sdt.rs
new file mode 100644
index 0000000000..26b55db22d
--- /dev/null
+++ b/crates/docx/src/read/sdt.rs
@@ -0,0 +1,104 @@
+//! Content control properties (`w:sdtPr`, ECMA-376 §17.5.2; check boxes and repeating
+//! sections from the [MS-DOCX] `w14`/`w15` extensions).
+
+use wordcraft_doc::control::{CHECKED, ContentControl, ControlKind, ControlLock, ListItem, MAX_CONTROL_TEXT, MAX_LIST_ITEMS, UNCHECKED};
+
+use crate::xml::El;
+
+/// Most bytes of `w:sdtPr` children kept verbatim per control.
+const MAX_EXTRA: usize = 64 * 1024;
+
+fn text(v: Option<&str>) -> String {
+    let v = v.unwrap_or("");
+    v.chars().filter(|c| *c != wordcraft_doc::para::OBJ && !c.is_control()).take(MAX_CONTROL_TEXT).collect()
+}
+
+/// An on/off element: on unless its value (`w:val`, or the extension's own) says off.
+fn on(e: &El) -> bool {
+    e.attr("w:val").or_else(|| e.attr("w14:val")).or_else(|| e.attr("w15:val")).is_none_or(|v| !matches!(v, "0" | "false" | "off"))
+}
+
+fn symbol(e: Option<&El>, default: char) -> (char, String) {
+    let Some(e) = e else { return (default, String::new()) };
+    let ch = e
+        .attr("w14:val")
+        .and_then(|h| u32::from_str_radix(h.trim(), 16).ok())
+        .and_then(char::from_u32)
+        .filter(|c| *c as u32 >= 0x20 && *c != wordcraft_doc::para::OBJ);
+    (ch.unwrap_or(default), text(e.attr("w14:font")))
+}
+
+fn items(e: &El) -> Vec<ListItem> {
+    e.children("w:listItem")
+        .take(MAX_LIST_ITEMS)
+        .map(|i| ListItem { display: text(i.attr("w:displayText")), value: text(i.attr("w:value")) })
+        .collect()
+}
+
+/// The control described by `w:sdtPr` (`None`: an `w:sdt` without one, a rich text control).
+pub fn sdt_pr(pr: Option<&El>, block: bool) -> ContentControl {
+    let mut c = ContentControl { block, ..Default::default() };
+    let Some(pr) = pr else { return c };
+    let mut extra_len = 0;
+    for k in pr.els() {
+        match k.name.as_str() {
+            "w:rPr" => c.rpr_xml = k.to_xml(),
+            "w:alias" => c.title = text(k.attr("w:val")),
+            "w:tag" => c.tag = text(k.attr("w:val")),
+            "w:id" => c.id = k.attr("w:val").and_then(|v| v.trim().parse::<i64>().ok()),
+            "w:lock" => c.lock = ControlLock::from_ooxml(k.attr("w:val").unwrap_or("")),
+            "w:placeholder" => c.placeholder = text(k.child("w:docPart").and_then(|d| d.attr("w:val"))),
+            "w:temporary" => c.temporary = on(k),
+            "w:showingPlcHdr" => c.showing_placeholder = on(k),
+            "w:richText" => c.kind = ControlKind::RichText,
+            "w:text" => c.kind = ControlKind::Text { multi_line: k.attr("w:multiLine").is_some_and(|v| !matches!(v, "0" | "false" | "off")) },
+            "w14:checkbox" => {
+                let checked = k.child("w14:checked").is_some_and(on);
+                let (checked_char, checked_font) = symbol(k.child("w14:checkedState"), CHECKED);
+                let (unchecked_char, unchecked_font) = symbol(k.child("w14:uncheckedState"), UNCHECKED);
+                c.kind = ControlKind::CheckBox { checked, checked_char, checked_font, unchecked_char, unchecked_font };
+            }
+            "w:comboBox" => c.kind = ControlKind::ComboBox { items: items(k), last_value: text(k.attr("w:lastValue")) },
+            "w:dropDownList" => c.kind = ControlKind::DropDown { items: items(k), last_value: text(k.attr("w:lastValue")) },
+            "w:date" => {
+                let v = |n: &str| text(k.child_val(n));
+                c.kind = ControlKind::Date {
+                    full_date: text(k.attr("w:fullDate")),
+                    format: v("w:dateFormat"),
+                    lid: v("w:lid"),
+                    calendar: v("w:calendar"),
+                    store_as: v("w:storeMappedDataAs"),
+                };
+            }
+            "w:picture" => c.kind = ControlKind::Picture,
+            "w:docPartObj" | "w:docPartList" => {
+                c.kind = ControlKind::Gallery {
+                    list: k.name == "w:docPartList",
+                    gallery: text(k.child_val("w:docPartGallery")),
+                    category: text(k.child_val("w:docPartCategory")),
+                    unique: k.child("w:docPartUnique").is_some_and(on),
+                };
+            }
+            "w15:repeatingSection" => {
+                c.kind = ControlKind::RepeatingSection {
+                    title: text(k.child("w15:sectionTitle").and_then(|t| t.attr("w:val").or_else(|| t.attr("w15:val")))),
+                    no_insert_delete: k.child("w15:doNotAllowInsertDeleteSection").is_some_and(on),
+                };
+            }
+            "w15:repeatingSectionItem" => c.kind = ControlKind::RepeatingSectionItem,
+            _ => {
+                let x = k.to_xml();
+                if !x.is_empty() && extra_len + x.len() <= MAX_EXTRA {
+                    extra_len += x.len();
+                    c.extra.push(x);
+                }
+            }
+        }
+    }
+    c
+}
+
+/// `w:sdtEndPr`, kept verbatim.
+pub fn sdt_end_pr(e: Option<&El>) -> String {
+    e.map(|e| e.to_xml()).filter(|x| x.len() <= MAX_EXTRA).unwrap_or_default()
+}
diff --git a/crates/docx/src/read/shape_style.rs b/crates/docx/src/read/shape_style.rs
new file mode 100644
index 0000000000..23cf106a15
--- /dev/null
+++ b/crates/docx/src/read/shape_style.rs
@@ -0,0 +1,177 @@
+//! How a Word shape (`wps:wsp`) looks: its preset geometry, and the fill and outline it gets from its own properties (`wps:spPr`) or, failing those, from the theme through its
+//! style references (`wps:style`: `a:fillRef`, `a:lnRef`, ECMA-376 Part 1 §20.1.4.2).
+
+use wordcraft_doc::para::ShapeKind;
+use wordcraft_doc::props::Rgb;
+
+use super::drawing_color::{color, fill_colour};
+use crate::units::{int, measure};
+use crate::xml::El;
+
+/// Outline widths of the theme's three line styles (`a:lnStyleLst`), points: what Word's
+/// default themes give (6 350, 12 700 and 19 050 EMU).
+const THEME_LINE_WIDTHS: [f32; 3] = [0.5, 1.0, 1.5];
+
+/// The shape kind drawn for DrawingML preset geometry `prst` (ECMA-376 Part 1 §20.1.10.56).
+/// Presets WordCraft has no shape for are drawn as the nearest one it has: callouts as the box,
+/// round or cloud they point from, flowchart boxes as rectangles.
+pub(crate) fn preset_kind(prst: &str) -> ShapeKind {
+    match prst {
+        "roundRect"
+        | "round1Rect"
+        | "round2SameRect"
+        | "round2DiagRect"
+        | "snipRoundRect"
+        | "wedgeRoundRectCallout"
+        | "flowChartAlternateProcess"
+        | "flowChartTerminator"
+        | "plaque" => ShapeKind::RoundedRectangle,
+        "ellipse" | "wedgeEllipseCallout" | "cloudCallout" | "cloud" | "flowChartConnector" | "donut" | "flowChartOnlineStorage" => {
+            ShapeKind::Ellipse
+        }
+        "triangle" | "rtTriangle" | "flowChartExtract" | "flowChartMerge" => ShapeKind::Triangle,
+        "diamond" | "flowChartDecision" => ShapeKind::Diamond,
+        "line" | "lineInv" => ShapeKind::Line,
+        "straightConnector1" => ShapeKind::StraightConnector,
+        "bentConnector2" | "bentConnector3" | "bentConnector4" | "bentConnector5" => ShapeKind::ElbowConnector,
+        "curvedConnector2" | "curvedConnector3" | "curvedConnector4" | "curvedConnector5" => ShapeKind::CurvedConnector,
+        "rightArrow" | "leftArrow" | "upArrow" | "downArrow" | "leftRightArrow" | "upDownArrow" | "notchedRightArrow" | "stripedRightArrow" => {
+            ShapeKind::Arrow
+        }
+        "star4" | "star5" | "star6" | "star7" | "star8" | "star10" | "star12" | "star16" | "star24" | "star32" => ShapeKind::Star,
+        "heart" => ShapeKind::Heart,
+        _ => ShapeKind::Rectangle,
+    }
+}
+
+/// A shape's fill and outline.
+#[derive(Debug, Default, PartialEq)]
+pub(crate) struct ShapePaint {
+    pub fill: Option<Rgb>,
+    pub stroke: Option<Rgb>,
+    /// Points.
+    pub stroke_width: f32,
+}
+
+/// The paint of a shape from its properties `sppr`, falling back on its style `style` (theme
+/// colours `theme`) for what they leave out: an explicit `a:noFill` is no fill or outline, an
+/// explicit colour wins, and a style reference with index 0 is none.
+pub(crate) fn shape_paint(sppr: Option<&El>, style: Option<&El>, theme: &[Rgb]) -> ShapePaint {
+    let style_ref = |name: &str| -> Option<(i64, &El)> {
+        let r = style?.child(name)?;
+        Some((r.attr("idx").and_then(int).unwrap_or(0), r))
+    };
+    let fill = match sppr {
+        Some(s) if s.child("a:noFill").is_some() || s.child("a:blipFill").is_some() => None,
+        Some(s) if s.els().any(|c| matches!(c.name.as_str(), "a:solidFill" | "a:gradFill" | "a:pattFill")) => fill_colour(s, theme),
+        _ => style_ref("a:fillRef").filter(|(idx, _)| *idx > 0).and_then(|(_, r)| color(r, theme)),
+    };
+    let ln = sppr.and_then(|s| s.child("a:ln"));
+    let line_ref = style_ref("a:lnRef").filter(|(idx, _)| *idx > 0);
+    let stroke = match ln {
+        Some(l) if l.child("a:noFill").is_some() => None,
+        Some(l) if l.els().any(|c| matches!(c.name.as_str(), "a:solidFill" | "a:gradFill" | "a:pattFill")) => fill_colour(l, theme),
+        _ => line_ref.and_then(|(_, r)| color(r, theme)),
+    };
+    let themed_width = line_ref.and_then(|(idx, _)| THEME_LINE_WIDTHS.get(usize::try_from(idx.clamp(1, 3) - 1).unwrap_or(0)).copied());
+    let stroke_width = ln
+        .and_then(|l| l.attr("w"))
+        .and_then(|v| measure(v, 12_700.0))
+        .or(themed_width)
+        // Word's default outline when the file names none (no outline: no width).
+        .unwrap_or(if stroke.is_some() { 0.75 } else { 0.0 })
+        .clamp(0.0, 100.0);
+    ShapePaint { fill, stroke, stroke_width }
+}
+
+/// A VML colour (`strokecolor`, `fillcolor`): `#rrggbb` or `#rgb` (Word follows it with the
+/// theme slot, as in `#4472c4 [3204]`), or a colour name.
+pub(crate) fn vml_color(v: &str) -> Option<Rgb> {
+    let v = v.split_whitespace().next()?;
+    if let Some(hex) = v.strip_prefix('#') {
+        if hex.len() == 3 && hex.is_ascii() {
+            let long: String = hex.chars().flat_map(|c| [c, c]).collect();
+            return Rgb::parse(&long);
+        }
+        return Rgb::parse(hex);
+    }
+    super::drawing_color::preset_color(v)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use wordcraft_doc::THEME_COLORS;
+
+    fn el(xml: &str) -> El {
+        let ns = r#"xmlns:wps="http://schemas.microsoft.com/office/word/2010/wordprocessingShape" xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main""#;
+        crate::xml::parse(xml.replace(r#"xmlns:wps="w" xmlns:a="a""#, ns).as_bytes()).unwrap()
+    }
+
+    #[test]
+    fn theme_styled_connector_gets_its_line_from_the_style() {
+        // A connector with no colour of its own (what Word writes for Insert › Shapes › Line):
+        // its outline comes from `a:lnRef`, its width from the theme's first line style.
+        let sp = el(r#"<wps:spPr xmlns:wps="w" xmlns:a="a"><a:prstGeom prst="line"/><a:ln><a:tailEnd type="triangle"/></a:ln></wps:spPr>"#);
+        let st = el(
+            r#"<wps:style xmlns:wps="w" xmlns:a="a"><a:lnRef idx="1"><a:schemeClr val="accent4"/></a:lnRef><a:fillRef idx="0"><a:schemeClr val="accent4"/></a:fillRef></wps:style>"#,
+        );
+        let p = shape_paint(Some(&sp), Some(&st), &THEME_COLORS);
+        assert_eq!(p.stroke, Some(THEME_COLORS[7]));
+        assert_eq!(p.stroke_width, 0.5);
+        assert_eq!(p.fill, None);
+    }
+
+    #[test]
+    fn explicit_paint_wins_over_the_style() {
+        let sp = el(r#"<wps:spPr xmlns:wps="w" xmlns:a="a"><a:noFill/><a:ln><a:solidFill><a:srgbClr val="EE0000"/></a:solidFill></a:ln></wps:spPr>"#);
+        let st = el(
+            r#"<wps:style xmlns:wps="w" xmlns:a="a"><a:lnRef idx="2"><a:schemeClr val="accent1"><a:shade val="15000"/></a:schemeClr></a:lnRef><a:fillRef idx="1"><a:schemeClr val="accent1"/></a:fillRef></wps:style>"#,
+        );
+        let p = shape_paint(Some(&sp), Some(&st), &THEME_COLORS);
+        assert_eq!((p.fill, p.stroke, p.stroke_width), (None, Some(Rgb(0xEE, 0, 0)), 1.0));
+        // Preset and scheme colours as the box's own fill and outline.
+        let sp = el(
+            r#"<wps:spPr xmlns:wps="w" xmlns:a="a"><a:solidFill><a:schemeClr val="lt1"/></a:solidFill><a:ln w="6350"><a:solidFill><a:prstClr val="black"/></a:solidFill></a:ln></wps:spPr>"#,
+        );
+        let p = shape_paint(Some(&sp), None, &THEME_COLORS);
+        assert_eq!((p.fill, p.stroke, p.stroke_width), (Some(THEME_COLORS[1]), Some(Rgb(0, 0, 0)), 0.5));
+        // A style fill with index 0 is none; an outline set to no fill is none.
+        let sp = el(r#"<wps:spPr xmlns:wps="w" xmlns:a="a"><a:ln><a:noFill/></a:ln></wps:spPr>"#);
+        let st = el(
+            r#"<wps:style xmlns:wps="w" xmlns:a="a"><a:lnRef idx="2"><a:schemeClr val="accent1"/></a:lnRef><a:fillRef idx="0"><a:schemeClr val="accent1"/></a:fillRef></wps:style>"#,
+        );
+        let p = shape_paint(Some(&sp), Some(&st), &THEME_COLORS);
+        assert_eq!((p.fill, p.stroke), (None, None));
+    }
+
+    #[test]
+    fn hostile_style_references_do_not_panic() {
+        let st = el(
+            r#"<wps:style xmlns:wps="w" xmlns:a="a"><a:lnRef idx="-99999999999"><a:schemeClr val="nope"/></a:lnRef><a:fillRef idx="99999999999"/></wps:style>"#,
+        );
+        let p = shape_paint(None, Some(&st), &[]);
+        assert_eq!((p.fill, p.stroke), (None, None));
+        let st = el(r#"<wps:style xmlns:wps="w" xmlns:a="a"><a:lnRef idx="77"><a:srgbClr val="010203"/></a:lnRef></wps:style>"#);
+        assert_eq!(shape_paint(None, Some(&st), &[]).stroke_width, 1.5);
+    }
+
+    #[test]
+    fn presets_map_to_the_nearest_shape() {
+        assert_eq!(preset_kind("straightConnector1"), ShapeKind::StraightConnector);
+        assert_eq!(preset_kind("bentConnector3"), ShapeKind::ElbowConnector);
+        assert_eq!(preset_kind("wedgeRoundRectCallout"), ShapeKind::RoundedRectangle);
+        assert_eq!(preset_kind("wedgeEllipseCallout"), ShapeKind::Ellipse);
+        assert_eq!(preset_kind("wedgeRectCallout"), ShapeKind::Rectangle);
+        assert_eq!(preset_kind("flowChartDecision"), ShapeKind::Diamond);
+    }
+
+    #[test]
+    fn vml_colours() {
+        assert_eq!(vml_color("#ffc000 [3207]"), Some(Rgb(0xFF, 0xC0, 0)));
+        assert_eq!(vml_color("#f00"), Some(Rgb(0xFF, 0, 0)));
+        assert_eq!(vml_color("black"), Some(Rgb(0, 0, 0)));
+        assert_eq!(vml_color("#é"), None);
+        assert_eq!(vml_color(""), None);
+    }
+}
diff --git a/crates/docx/src/read/story.rs b/crates/docx/src/read/story.rs
index b17f219e2a..c6f724ca27 100644
--- a/crates/docx/src/read/story.rs
+++ b/crates/docx/src/read/story.rs
@@ -2,18 +2,22 @@
 
 use std::sync::Arc;
 
+use wordcraft_doc::connector::{ConnEnd, ShapeExtra};
+use wordcraft_doc::control::{ContentControl, ControlKind, ControlWrap};
 use wordcraft_doc::effects::{Glow, Shadow, ShapeEffects};
 use wordcraft_doc::graphic::{Embedded, Graphic, GraphicItem, GraphicKind};
-use wordcraft_doc::para::{Anchor, Float, FloatAlign, NoteKind, ShapeKind, Wrap, WrapText};
+use wordcraft_doc::para::{AltText, Anchor, Float, FloatAlign, NoteKind, ShapeKind, Wrap, WrapText, cap_alt};
 use wordcraft_doc::props::{CharProps, NumChange, PropChange, Rgb};
 use wordcraft_doc::table::{Cell, MAX_COLS, MAX_ROWS, Row, Table};
 use wordcraft_doc::{Block, Blocks, InlineObject, Paragraph, PartKind, RevisionKind, Run, para_block};
 
 use super::Reader;
 use super::props::{sectpr, tcpr, trpr};
+use super::shape_style::{preset_kind, shape_paint, vml_color};
 use crate::package::{Rels, rt};
-use crate::units::{int, measure};
+use crate::units::{int, measure, u32_of};
 use crate::xml::El;
+use wordcraft_doc::wordart::TextWarp;
 
 /// Deepest table nesting we build (deeper tables become plain paragraphs).
 const MAX_TABLE_DEPTH: usize = 24;
@@ -38,9 +42,11 @@ enum Phase {
     Result,
 }
 
+/// A buffered piece of a field's result. Objects are boxed: an inline object is much larger than
+/// a string.
 enum Item {
     Text(String),
-    Obj(InlineObject),
+    Obj(Box<InlineObject>),
 }
 
 struct FieldState {
@@ -82,6 +88,16 @@ fn is_range_instr(instr: &str) -> bool {
     instr.trim_start().get(..5).is_some_and(|k| k.eq_ignore_ascii_case("ADDIN"))
 }
 
+/// The last paragraph of a block list: its last block, or inside a final table the last
+/// paragraph of its last cell (nested tables to [`MAX_TABLE_DEPTH`]).
+fn last_para_mut(out: &mut Blocks, depth: usize) -> Option<&mut Paragraph> {
+    match Arc::make_mut(out.last_mut()?) {
+        Block::Para(p) => Some(p),
+        Block::Table(t) if depth < MAX_TABLE_DEPTH => last_para_mut(&mut t.rows.last_mut()?.cells.last_mut()?.blocks, depth + 1),
+        Block::Table(_) => None,
+    }
+}
+
 /// The field that buffers content now: the innermost one that isn't a range field, unless it
 /// has spilled (then content goes straight into the paragraph).
 fn sink(sc: &mut StoryCtx) -> Option<&mut FieldState> {
@@ -187,18 +203,14 @@ impl Reader<'_> {
                         out.push(Arc::new(Block::Table(t)));
                     }
                 }
-                "w:sdt" => {
-                    if let Some(c) = e.child("w:sdtContent") {
-                        self.read_blocks(sc, c, rels, out, depth + 1);
-                    }
-                }
+                "w:sdt" => self.read_block_sdt(sc, e, rels, out, depth),
                 "w:customXml" | "w:smartTag" | "w:ins" | "w:moveTo" => self.read_blocks(sc, e, rels, out, depth + 1),
                 "mc:AlternateContent" => {
                     if let Some(c) = children_of_choice(e) {
                         self.read_blocks(sc, c, rels, out, depth + 1);
                     }
                 }
-                "w:bookmarkStart" | "w:bookmarkEnd" | "w:commentRangeStart" | "w:commentRangeEnd" => {
+                "w:bookmarkStart" | "w:bookmarkEnd" | "w:commentRangeStart" | "w:commentRangeEnd" | "w:permStart" | "w:permEnd" => {
                     if let Some(o) = self.marker(e) {
                         sc.pending.push(o);
                     }
@@ -209,12 +221,55 @@ impl Reader<'_> {
         }
     }
 
-    /// Markers left over at the end of a story go to its last paragraph.
+    /// A block-level content control: its content's blocks, between a start marker at the start
+    /// of the first paragraph and an end marker at the end of the last (a table at either end
+    /// carries the control instead).
+    fn read_block_sdt(&mut self, sc: &mut StoryCtx, e: &El, rels: &Rels, out: &mut Blocks, depth: usize) {
+        let Some(content) = e.child("w:sdtContent") else { return };
+        let mut ctl = super::sdt::sdt_pr(e.child("w:sdtPr"), true);
+        ctl.end_pr_xml = super::sdt::sdt_end_pr(e.child("w:sdtEndPr"));
+        let mut inner = Blocks::new();
+        self.read_blocks(sc, content, rels, &mut inner, depth + 1);
+        // A table of contents' control belongs to the TOC: the writer puts it back around the
+        // TOC field and its entries, which References › Update Table rebuilds.
+        let toc = matches!(&ctl.kind, ControlKind::Gallery { list: false, gallery, .. } if gallery == "Table of Contents");
+        if inner.is_empty() || toc {
+            out.extend(inner);
+            return;
+        }
+        if ctl.showing_placeholder
+            && let Some(Block::Para(p)) = inner.first().map(|b| &**b)
+        {
+            ctl.placeholder_text = placeholder_of(&p.plain_text());
+        }
+        if let Some(first) = inner.first_mut() {
+            match Arc::make_mut(first) {
+                Block::Para(p) => {
+                    let props = p.props_of_char(0).clone();
+                    let _ = p.insert_object(0, InlineObject::ControlStart { control: Box::new(ctl) }, &props);
+                }
+                Block::Table(t) => t.controls.open.insert(0, ctl),
+            }
+        }
+        if let Some(last) = inner.last_mut() {
+            match Arc::make_mut(last) {
+                Block::Para(p) => {
+                    let (at, props) = (p.len(), p.runs.last().map(|r| r.props.clone()).unwrap_or_else(|| p.mark.clone()));
+                    let _ = p.insert_object(at, InlineObject::ControlEnd, &props);
+                }
+                Block::Table(t) => t.controls.close = t.controls.close.saturating_add(1),
+            }
+        }
+        out.extend(inner);
+    }
+
+    /// Markers left over at the end of a story go to its last paragraph (after a final table:
+    /// the last paragraph of its last cell, so a bookmark around the table keeps its end).
     pub fn flush_pending(&mut self, sc: &mut StoryCtx, out: &mut Blocks) {
         if sc.pending.is_empty() {
             return;
         }
-        if let Some(Block::Para(p)) = out.last_mut().map(Arc::make_mut) {
+        if let Some(p) = last_para_mut(out, 0) {
             for o in sc.pending.drain(..) {
                 let props = p.runs.last().map(|r| r.props.clone()).unwrap_or_default();
                 p.text.push(wordcraft_doc::para::OBJ);
@@ -239,6 +294,21 @@ impl Reader<'_> {
             }
             "w:bookmarkEnd" => self.bookmarks.get(&id).map(|n| InlineObject::BookmarkEnd { name: n.clone() }),
             "w:commentRangeStart" => self.comment_id(&id).map(|id| InlineObject::CommentStart { id }),
+            "w:permStart" => {
+                // Bounded: a hostile file can't grow the map without end.
+                if self.perms.len() >= 100_000 {
+                    return None;
+                }
+                let n = self.perms.len() as u32;
+                let id = *self.perms.entry(id).or_insert(n);
+                let text = |a: &str| e.attr(a).filter(|v| v.len() <= 256).unwrap_or("").to_string();
+                let (group, editor) = (text("w:edGrp"), text("w:ed"));
+                if group.is_empty() && editor.is_empty() {
+                    return None;
+                }
+                Some(InlineObject::PermStart { id, group, editor })
+            }
+            "w:permEnd" => self.perms.get(&id).map(|id| InlineObject::PermEnd { id: *id }),
             "w:commentRangeEnd" => {
                 let cid = self.comment_id(&id)?;
                 self.comments_ended.insert(cid);
@@ -387,7 +457,7 @@ impl Reader<'_> {
                 self.read_inline_children(sc, pb, k, rels, ctx, depth + 1);
                 self.end_field(sc, pb);
             }
-            "w:bookmarkStart" | "w:bookmarkEnd" | "w:commentRangeStart" | "w:commentRangeEnd" => {
+            "w:bookmarkStart" | "w:bookmarkEnd" | "w:commentRangeStart" | "w:commentRangeEnd" | "w:permStart" | "w:permEnd" => {
                 if let Some(o) = self.marker(k) {
                     let props = self.run_props_none(ctx);
                     // Markers go straight into the paragraph (never into a field's cached result).
@@ -395,9 +465,23 @@ impl Reader<'_> {
                 }
             }
             "w:sdt" => {
-                if let Some(c) = k.child("w:sdtContent") {
-                    self.read_inline_children(sc, pb, c, rels, ctx, depth + 1);
+                let Some(c) = k.child("w:sdtContent") else { return };
+                let mut ctl = super::sdt::sdt_pr(k.child("w:sdtPr"), false);
+                ctl.end_pr_xml = super::sdt::sdt_end_pr(k.child("w:sdtEndPr"));
+                // The markers take the formatting of the content's first run (typing at the
+                // start of the content continues it).
+                let props = c.find("w:rPr").map(|p| self.run_props(p, ctx)).unwrap_or_else(|| self.run_props_none(ctx));
+                let (at, k0) = (pb.text.len(), pb.objects.len());
+                pb.push_obj(InlineObject::ControlStart { control: Box::new(ctl) }, &props);
+                self.read_inline_children(sc, pb, c, rels, ctx, depth + 1);
+                if let Some(InlineObject::ControlStart { control }) = pb.objects.get_mut(k0)
+                    && control.showing_placeholder
+                {
+                    let shown: String = pb.text.get(at..).unwrap_or("").chars().filter(|c| *c != wordcraft_doc::para::OBJ).collect();
+                    control.placeholder_text = placeholder_of(&shown);
                 }
+                let end_props = pb.runs.last().map(|r| r.props.clone()).unwrap_or(props);
+                pb.push_obj(InlineObject::ControlEnd, &end_props);
             }
             "w:smartTag" | "w:customXml" | "w:dir" | "w:bdo" => self.read_inline_children(sc, pb, k, rels, ctx, depth + 1),
             "m:oMath" => {
@@ -698,6 +782,20 @@ impl Reader<'_> {
             self.emit_obj(sc, pb, InlineObject::FieldEnd, &f.props);
             return;
         }
+        // A cached result holding a picture, chart or shape (`INCLUDEPICTURE`'s embedded
+        // picture) can't be a text result: keep the field as a range around it so the picture
+        // stays in the document and is saved again. The linked source is never read.
+        if !nested_in_instr && f.buf.iter().any(|(it, _)| matches!(it, Item::Obj(o) if o.frame().is_some())) {
+            self.emit_obj(sc, pb, InlineObject::FieldStart { instr: f.instr.trim().to_string(), locked: f.locked }, &f.props);
+            for (it, p) in f.buf {
+                match it {
+                    Item::Text(t) => self.emit_text(sc, pb, &t, &p),
+                    Item::Obj(o) => self.emit_obj(sc, pb, *o, &p),
+                }
+            }
+            self.emit_obj(sc, pb, InlineObject::FieldEnd, &f.props);
+            return;
+        }
         let mut result = String::new();
         for (it, _) in &f.buf {
             match it {
@@ -733,7 +831,7 @@ impl Reader<'_> {
             for (it, p) in f.buf.drain(..) {
                 match it {
                     Item::Text(t) => pb.push_text(&t, &p),
-                    Item::Obj(o) => pb.push_obj(o, &p),
+                    Item::Obj(o) => pb.push_obj(*o, &p),
                 }
             }
         }
@@ -754,7 +852,7 @@ impl Reader<'_> {
         match sink(sc) {
             Some(f) => {
                 if f.phase == Phase::Result && f.buf.len() < 100_000 {
-                    f.buf.push((Item::Obj(o), props.clone()));
+                    f.buf.push((Item::Obj(Box::new(o)), props.clone()));
                 }
             }
             _ => pb.push_obj(o, props),
@@ -771,8 +869,9 @@ impl Reader<'_> {
         let ext = c.child("wp:extent");
         let dim = |n: &str| ext.and_then(|e| e.attr(n)).and_then(|v| measure(v, 12_700.0)).unwrap_or(0.0).clamp(0.0, crate::units::MAX_LEN_PT);
         let (w, h) = (dim("cx"), dim("cy"));
-        let alt = c.child("wp:docPr").and_then(|p| p.attr("descr").filter(|s| !s.is_empty()).or_else(|| p.attr("title"))).unwrap_or("").to_string();
+        let (alt, meta) = nv_alt(c.child("wp:docPr"));
         let mut float = if anchored { anchor_float(c) } else { Float::default() };
+        float.alt = meta;
         if let Some(e) = c.child("wp:effectExtent") {
             for (slot, n) in float.effect.iter_mut().zip(["l", "t", "r", "b"]) {
                 // Negative for a rotated object narrower than its frame; settled below.
@@ -806,7 +905,7 @@ impl Reader<'_> {
         } else if let Some(g) = gd.child("wpg:wgp") {
             self.read_group(sc, g, rels, w, h, float)?
         } else if gd.find("a:blip").is_some() {
-            self.read_pic(gd, rels, w, h, alt, float)?
+            self.read_pic(gd, rels, w, h, alt.clone(), float)?
         } else {
             let wsp = gd.find("wps:wsp")?;
             let mut obj = self.read_wsp(sc, wsp, rels, w, h, float);
@@ -816,12 +915,18 @@ impl Reader<'_> {
                 && let Some(mut f) = super::freeform::cust_geom(sppr, w, h)
             {
                 f.alpha = super::freeform::line_alpha(sppr.child("a:ln"));
-                f.ink = c.child("wp:docPr").and_then(|p| p.attr("name")).and_then(super::freeform::ink_tool);
+                let name = c.child("wp:docPr").and_then(|p| p.attr("name"));
+                f.ink = name.and_then(super::freeform::ink_tool);
+                f.order = name.filter(|_| f.ink.is_some()).and_then(super::freeform::ink_order);
                 *kind = ShapeKind::Freeform;
                 *freeform = Some(Arc::new(f));
             }
             obj
         };
+        if !alt.is_empty() {
+            obj.set_alt_text(&alt);
+        }
+        self.set_shape_id(&mut obj, c.child("wp:docPr").and_then(|p| p.attr("id")));
         // Word's effect extent also covers a rotated object's overhang; the model keeps that
         // apart (it follows from the angle), so take it back out.
         if let Some(f) = obj.float_mut() {
@@ -842,14 +947,25 @@ impl Reader<'_> {
             GraphicKind::Chart => gd.child("c:chart").and_then(|c| c.attr("r:id")).and_then(|id| super::part_of(rels, id, rt::CHART)),
             GraphicKind::Diagram => self.diagram_part(gd, rels),
         };
-        let Some(path) = part else { return Arc::new(Graphic { kind, items: Vec::new(), w, h, source }) };
+        let Some(path) = part else { return Arc::new(Graphic { kind, items: Vec::new(), w, h, source, chart: None, smart_art: None }) };
         let key = (kind, path, w.to_bits(), h.to_bits());
         if let Some(g) = self.graphics.get(&key) {
             return g.clone();
         }
         let items = if self.graphic_budget == 0 { Vec::new() } else { self.graphic_items(kind, &key.1, w, h) };
         self.graphic_budget = self.graphic_budget.saturating_sub(graphic_work(&items));
-        let g = Arc::new(Graphic { kind, items, w, h, source });
+        // A chart or SmartArt that is exactly what WordCraft writes for its model can be edited
+        // (and is written from the model); any other stays as it was read.
+        let chart = match kind {
+            GraphicKind::Chart if !items.is_empty() => self.graphic_part(&key.1).and_then(|space| crate::chart_spec::spec_of(&space)).map(Arc::new),
+            _ => None,
+        };
+        let smart_art = match kind {
+            GraphicKind::Diagram if !items.is_empty() => self.smart_art_spec(gd, rels).map(Arc::new),
+            _ => None,
+        };
+        let source = if chart.is_some() || smart_art.is_some() { None } else { source };
+        let g = Arc::new(Graphic { kind, items, w, h, source, chart, smart_art });
         self.graphics.insert(key, g.clone());
         g
     }
@@ -971,12 +1087,19 @@ impl Reader<'_> {
             let max = crate::units::MAX_LEN_PT;
             let fit = |v: f32, lo: f32| wordcraft_geom::finite(v).clamp(lo, max);
             let (w, h) = (fit(ew * sx, 0.0), fit(eh * sy, 0.0));
+            let (alt, meta) = nv_alt(if e.name == "pic:pic" { e.find("pic:cNvPr") } else { e.child("wps:cNvPr") });
+            let float = Float { alt: meta, ..Float::default() };
             let obj = if e.name == "pic:pic" {
-                let alt = e.find("pic:cNvPr").and_then(|p| p.attr("descr")).unwrap_or("").to_string();
-                self.read_pic(e, rels, w, h, alt, Float::default())
+                self.read_pic(e, rels, w, h, alt.clone(), float)
             } else {
-                Some(self.read_wsp(sc, e, rels, w, h, Float::default()))
+                let mut o = self.read_wsp(sc, e, rels, w, h, float);
+                self.set_shape_id(&mut o, e.child("wps:cNvPr").and_then(|p| p.attr("id")));
+                Some(o)
             };
+            let obj = obj.map(|mut o| {
+                o.set_alt_text(&alt);
+                o
+            });
             if let Some(obj) = obj {
                 out.push(wordcraft_doc::para::GroupChild { x: fit(x0 + ox * sx, -max), y: fit(y0 + oy * sy, -max), obj });
             }
@@ -988,28 +1111,16 @@ impl Reader<'_> {
         float.set_spin(xfrm_spin(sppr));
         let prst = sppr.and_then(|s| s.child("a:prstGeom")).and_then(|g| g.attr("prst")).unwrap_or("rect");
         let txbx = wsp.child("wps:txbx").and_then(|t| t.child("w:txbxContent"));
-        let mut kind = match prst {
-            "roundRect" => ShapeKind::RoundedRectangle,
-            "ellipse" => ShapeKind::Ellipse,
-            "triangle" | "rtTriangle" => ShapeKind::Triangle,
-            "diamond" => ShapeKind::Diamond,
-            "line" | "straightConnector1" => ShapeKind::Line,
-            "rightArrow" | "leftArrow" | "upArrow" | "downArrow" => ShapeKind::Arrow,
-            "star5" | "star4" | "star6" => ShapeKind::Star,
-            "heart" => ShapeKind::Heart,
-            _ => ShapeKind::Rectangle,
-        };
+        let mut kind = preset_kind(prst);
         let is_tb = wsp.child("wps:cNvSpPr").and_then(|c| c.attr("txBox")).is_some_and(|v| v == "1" || v == "true");
         if is_tb || (txbx.is_some() && kind == ShapeKind::Rectangle) {
             kind = ShapeKind::TextBox;
         }
-        let solid = |e: Option<&El>| {
-            e.and_then(|f| f.child("a:solidFill")).and_then(|f| f.child("a:srgbClr")).and_then(|c| c.attr("val")).and_then(Rgb::parse)
-        };
-        let fill = solid(sppr);
+        // Explicit paint, else the theme's through the style references (#611).
+        let paint = shape_paint(sppr, wsp.child("wps:style"), &self.doc.settings.theme_colors);
+        let (stroke, stroke_width) = (paint.stroke, paint.stroke_width);
+        let fill = if kind.is_open() { None } else { paint.fill };
         let ln = sppr.and_then(|s| s.child("a:ln"));
-        let stroke = solid(ln);
-        let stroke_width = ln.and_then(|l| l.attr("w")).and_then(|v| measure(v, 12_700.0)).unwrap_or(0.0).clamp(0.0, 100.0);
         let effects = sppr.and_then(|s| s.child("a:effectLst")).map(effect_list).unwrap_or_default();
         let story = match txbx {
             Some(t) if sc.story_depth < MAX_STORY_DEPTH => Some(self.read_textbox(sc, t, rels)),
@@ -1050,7 +1161,35 @@ impl Reader<'_> {
                 part.body.anchor = wordcraft_doc::props::valign_from_anchor(a);
             }
         }
-        InlineObject::Shape { kind, w, h, fill, stroke, stroke_width, float, story, freeform: None, effects }
+        let mut extra = ShapeExtra::default();
+        // Arrowheads: any end type but `none` (ECMA-376 §20.1.10.33) is drawn as a triangle.
+        let arrow = |tag: &str| ln.and_then(|l| l.child(tag)).and_then(|e| e.attr("type")).is_some_and(|t| t != "none");
+        extra.arrow_start = arrow("a:headEnd");
+        extra.arrow_end = arrow("a:tailEnd");
+        // A connector's glued ends (ECMA-376 §20.1.2.2.36, §20.1.2.2.13).
+        if let Some(cn) = wsp.child("wps:cNvCnPr") {
+            let end = |tag: &str| {
+                let e = cn.child(tag)?;
+                let id = e.attr("id").and_then(u32_of).filter(|v| *v != 0)?;
+                let site = e.attr("idx").and_then(u32_of).unwrap_or(0).min(wordcraft_doc::connector::MAX_SITE);
+                Some(ConnEnd { id, site })
+            };
+            extra.start = end("a:stCxn");
+            extra.end = end("a:endCxn");
+            self.glued.extend(extra.start.iter().chain(extra.end.iter()).map(|e| e.id));
+        }
+        extra.warp = wsp.child("wps:bodyPr").and_then(|b| b.child("a:prstTxWarp")).and_then(text_warp);
+        InlineObject::Shape { kind, w, h, fill, stroke, stroke_width, float, story, freeform: None, effects, extra }
+    }
+
+    /// Keep drawing id `id` on a shape read from a file (see [`Reader::glued`]).
+    fn set_shape_id(&mut self, obj: &mut InlineObject, id: Option<&str>) {
+        if let InlineObject::Shape { extra, .. } = obj
+            && let Some(id) = id.and_then(u32_of).filter(|v| *v != 0)
+        {
+            extra.id = id;
+            self.shape_ids = true;
+        }
     }
 
     fn read_textbox(&mut self, sc: &StoryCtx, content: &El, rels: &Rels) -> u32 {
@@ -1061,39 +1200,86 @@ impl Reader<'_> {
         self.doc.add_part(PartKind::TextBox, blocks)
     }
 
-    /// Legacy VML pictures and text boxes (best effort).
+    /// Legacy VML pictures, text boxes, lines, rectangles and ovals (best effort).
     fn read_vml(&mut self, sc: &mut StoryCtx, pict: &El, rels: &Rels) -> Option<InlineObject> {
         let shape = pict.els().find(|e| e.name.starts_with("v:") && e.local() != "shapetype")?;
         let style = shape.attr("style").unwrap_or("");
         let len = |k: &str| vml_style(style, k).and_then(|v| measure(v, 1.0)).unwrap_or(0.0).clamp(0.0, crate::units::MAX_LEN_PT);
-        let (w, h) = (len("width"), len("height"));
-        let float = vml_float(shape, style);
+        let (mut w, mut h) = (len("width"), len("height"));
+        let mut float = vml_float(shape, style);
         if let Some(img) = shape.find("v:imagedata") {
             let id = img.attr("r:id").or_else(|| img.attr("r:pict"))?;
             let media = self.media_for(rels, id)?;
             let alt = shape.attr("alt").or_else(|| img.attr("o:title")).unwrap_or("").to_string();
             return Some(InlineObject::Image { media, w, h, alt, float, crop: [0.0; 4], ole: None });
         }
+        let on = |name: &str| shape.attr(name).is_none_or(|v| !matches!(v, "f" | "false" | "0"));
+        let stroke = on("stroked").then(|| shape.attr("strokecolor").map_or(Some(Rgb::BLACK), vml_color)).flatten();
+        let stroke_width = shape.attr("strokeweight").and_then(|v| measure(v, 1.0)).unwrap_or(0.75).clamp(0.0, 100.0);
+        let fill = on("filled").then(|| shape.attr("fillcolor").map_or(Some(Rgb::WHITE), vml_color)).flatten();
         if let Some(t) = shape.find("w:txbxContent")
             && sc.story_depth < MAX_STORY_DEPTH
         {
             let story = Some(self.read_textbox(sc, t, rels));
-            let fill = shape.attr("fillcolor").and_then(Rgb::parse);
-            let stroke = shape.attr("strokecolor").and_then(Rgb::parse);
             return Some(InlineObject::Shape {
                 kind: ShapeKind::TextBox,
                 w,
                 h,
                 fill,
                 stroke,
-                stroke_width: 0.75,
+                stroke_width,
                 float,
                 story,
                 freeform: None,
                 effects: Default::default(),
+                extra: Default::default(),
             });
         }
-        None
+        let kind = match shape.local() {
+            "line" => ShapeKind::Line,
+            "rect" => ShapeKind::Rectangle,
+            "roundrect" => ShapeKind::RoundedRectangle,
+            "oval" => ShapeKind::Ellipse,
+            _ => return None,
+        };
+        let mut extra = ShapeExtra::default();
+        if kind == ShapeKind::Line {
+            // A line runs `from` → `to` (points, offsets from where its style places it).
+            let pt = |name: &str| -> (f32, f32) {
+                let v = shape.attr(name).unwrap_or("0,0");
+                let (x, y) = v.split_once(',').unwrap_or((v, "0"));
+                let m = |s: &str| measure(s, 1.0).map_or(0.0, wordcraft_geom::finite).clamp(-crate::units::MAX_LEN_PT, crate::units::MAX_LEN_PT);
+                (m(x), m(y))
+            };
+            let ((x0, y0), (x1, y1)) = (pt("from"), pt("to"));
+            let max = crate::units::MAX_LEN_PT;
+            (w, h) = ((x1 - x0).abs().min(max), (y1 - y0).abs().min(max));
+            float.x = (float.x + x0.min(x1)).clamp(-max, max);
+            float.y = (float.y + y0.min(y1)).clamp(-max, max);
+            // Drawn top-left to bottom-right; flipped for the other directions.
+            float.flip_h ^= x1 < x0;
+            float.flip_v ^= y1 < y0;
+            // Arrowheads (`v:stroke` startarrow / endarrow): any but `none` is drawn.
+            let arrow = |name: &str| shape.child("v:stroke").and_then(|s| s.attr(name)).is_some_and(|v| v != "none");
+            extra.arrow_start = arrow("startarrow");
+            extra.arrow_end = arrow("endarrow");
+        }
+        if stroke.is_none() && (fill.is_none() || kind == ShapeKind::Line) {
+            return None;
+        }
+        Some(InlineObject::Shape {
+            kind,
+            w,
+            h,
+            fill: fill.filter(|_| kind != ShapeKind::Line),
+            stroke,
+            stroke_width,
+            float,
+            story: None,
+            freeform: None,
+            effects: Default::default(),
+            extra,
+        })
     }
 
     /// An OLE object (`w:object`, ECMA-376 §17.3.3.19): shown as its picture (VML, or a DrawingML
@@ -1131,20 +1317,22 @@ impl Reader<'_> {
                 .collect();
         }
         let mut rows = Vec::new();
-        collect(t, "w:tr", &mut rows, 0);
-        for tr in rows.into_iter().take(MAX_ROWS) {
-            let mut row = Row { props: tr.child("w:trPr").map(trpr).unwrap_or_default(), cells: Vec::new() };
+        collect(t, "w:tr", &mut rows, &mut Vec::new(), 0);
+        for (tr, row_controls) in rows.into_iter().take(MAX_ROWS) {
+            let mut row = Row { props: tr.child("w:trPr").map(trpr).unwrap_or_default(), cells: Vec::new(), controls: row_controls };
             if let Some(ch) = tr.child("w:trPr").and_then(|p| p.child("w:trPrChange")) {
                 let old = ch.child("w:trPr").map(trpr).unwrap_or_default();
                 row.props.fmt_change = PropChange::boxed(self.revision(RevisionKind::Format, ch), old);
             }
             let mut tcs = Vec::new();
-            collect(tr, "w:tc", &mut tcs, 0);
-            for tc in tcs.into_iter().take(MAX_COLS) {
-                let (mut props, hcont) =
-                    tc.child("w:tcPr").map(tcpr).unwrap_or_else(|| (wordcraft_doc::props::CellProps { span: 1, ..Default::default() }, false));
+            collect(tr, "w:tc", &mut tcs, &mut Vec::new(), 0);
+            for (tc, cell_controls) in tcs.into_iter().take(MAX_COLS) {
+                let (mut props, hcont) = tc
+                    .child("w:tcPr")
+                    .map(|p| tcpr(&self.pc, p))
+                    .unwrap_or_else(|| (wordcraft_doc::props::CellProps { span: 1, ..Default::default() }, false));
                 if let Some(ch) = tc.child("w:tcPr").and_then(|p| p.child("w:tcPrChange")) {
-                    let old = ch.child("w:tcPr").map(|o| tcpr(o).0).unwrap_or_default();
+                    let old = ch.child("w:tcPr").map(|o| tcpr(&self.pc, o).0).unwrap_or_default();
                     props.fmt_change = PropChange::boxed(self.revision(RevisionKind::Format, ch), old);
                 }
                 if hcont && let Some(prev) = row.cells.last_mut() {
@@ -1154,7 +1342,7 @@ impl Reader<'_> {
                 let mut blocks = Blocks::new();
                 self.read_blocks(sc, tc, rels, &mut blocks, depth + 4);
                 self.flush_pending(sc, &mut blocks);
-                row.cells.push(Cell { props, blocks });
+                row.cells.push(Cell { props, blocks, controls: cell_controls });
             }
             if !row.cells.is_empty() {
                 table.rows.push(row);
@@ -1171,28 +1359,64 @@ impl Reader<'_> {
     }
 }
 
-/// Gather `name` children, looking through `w:sdt`/`w:customXml` wrappers.
-fn collect<'a>(e: &'a El, name: &str, out: &mut Vec<&'a El>, depth: usize) {
+/// Gather `name` children (rows, cells), looking through `w:sdt`/`w:customXml` wrappers; each
+/// with the content controls that open before it and how many close after it. `pending` holds
+/// controls opened but not yet given to an element.
+fn collect<'a>(e: &'a El, name: &str, out: &mut Vec<(&'a El, ControlWrap)>, pending: &mut Vec<ContentControl>, depth: usize) {
     if depth > 8 {
         return;
     }
     for k in e.els() {
         if k.name == name {
-            out.push(k);
+            out.push((k, ControlWrap { open: std::mem::take(pending), close: 0 }));
         } else if k.name == "w:sdt" {
             if let Some(c) = k.child("w:sdtContent") {
-                collect(c, name, out, depth + 1);
+                let mut ctl = super::sdt::sdt_pr(k.child("w:sdtPr"), true);
+                ctl.end_pr_xml = super::sdt::sdt_end_pr(k.child("w:sdtEndPr"));
+                let before = out.len();
+                pending.push(ctl);
+                collect(c, name, out, pending, depth + 1);
+                let grew = out.len() > before;
+                match out.last_mut() {
+                    Some((_, w)) if grew => w.close = w.close.saturating_add(1),
+                    // Nothing inside: the control goes (as before).
+                    _ => {
+                        pending.pop();
+                    }
+                }
             }
         } else if k.name == "w:customXml" {
-            collect(k, name, out, depth + 1);
+            collect(k, name, out, pending, depth + 1);
         }
     }
 }
 
+/// Placeholder text as read from a control showing it: one line, bounded.
+fn placeholder_of(s: &str) -> String {
+    s.chars().map(|c| if c.is_control() { ' ' } else { c }).take(wordcraft_doc::control::MAX_CONTROL_TEXT).collect::<String>().trim().to_string()
+}
+
 fn on_off_attr(e: &El, name: &str) -> bool {
     e.attr(name).is_some_and(|v| !matches!(v, "0" | "false" | "off"))
 }
 
+/// The alternative text of a `wp:docPr`, `pic:cNvPr` or `wps:cNvPr` (ECMA-376
+/// `CT_NonVisualDrawingProps`): the description (the title when there is none, as before), and
+/// the title and decorative mark (the `adec:decorative` extension of [MS-ODRAWXML]).
+fn nv_alt(p: Option<&El>) -> (String, AltText) {
+    let Some(p) = p else { return Default::default() };
+    let title = cap_alt(p.attr("title").unwrap_or(""));
+    let descr = p.attr("descr").filter(|s| !s.is_empty()).map(cap_alt).unwrap_or_else(|| title.clone());
+    let decorative = p
+        .child("a:extLst")
+        .into_iter()
+        .flat_map(|l| l.children("a:ext"))
+        .filter(|x| x.attr("uri").is_some_and(|u| u.eq_ignore_ascii_case(crate::xml::DECORATIVE_EXT)))
+        .flat_map(|x| x.els())
+        .any(|d| d.local() == "decorative" && on_off_attr(d, "val"));
+    (descr, AltText { text: String::new(), title, decorative })
+}
+
 fn anchor_float(c: &El) -> Float {
     let mut f = Float { wrap: Wrap::Square, ..Float::default() };
     let behind = on_off_attr(c, "behindDoc");
@@ -1359,6 +1583,19 @@ fn graphic_work(items: &[GraphicItem]) -> usize {
 
 /// A shape's `a:effectLst` (ECMA-376 Part 1 §20.1.8.26): its outer shadow, glow and soft edges.
 /// Other effects are dropped.
+/// A preset text warp (`a:prstTxWarp`, ECMA-376 §20.1.9.19) and its adjust values
+/// (`a:avLst/a:gd` with `fmla="val N"`). Unknown presets are dropped.
+fn text_warp(e: &El) -> Option<TextWarp> {
+    let mut w = TextWarp::new(e.attr("prst")?)?;
+    for gd in e.child("a:avLst").into_iter().flat_map(|l| l.children("a:gd")) {
+        let (Some(name), Some(f)) = (gd.attr("name"), gd.attr("fmla")) else { continue };
+        if let Some(v) = f.trim().strip_prefix("val").and_then(|v| v.trim().parse::<i64>().ok()) {
+            w.set_adj(name, v);
+        }
+    }
+    Some(w)
+}
+
 fn effect_list(l: &El) -> ShapeEffects {
     let pt = |e: &El, n: &str| e.attr(n).and_then(|v| measure(v, 12_700.0)).unwrap_or(0.0);
     let shadow = l.child("a:outerShdw").map(|e| {
diff --git a/crates/docx/src/read/wordart.rs b/crates/docx/src/read/wordart.rs
new file mode 100644
index 0000000000..d8d558892c
--- /dev/null
+++ b/crates/docx/src/read/wordart.rs
@@ -0,0 +1,115 @@
+//! WordArt text effects in `w:rPr` ([MS-DOCX] §2.6.1: `w14:textFill`, `w14:textOutline`,
+//! `w14:shadow`, `w14:glow`, `w14:reflection`). Lengths are EMUs, angles 60000ths of a degree,
+//! percentages 1000ths of a percent.
+
+use wordcraft_doc::effects::{Glow, Shadow};
+use wordcraft_doc::props::Rgb;
+use wordcraft_doc::wordart::{GradStop, MAX_STOPS, Reflection, TextEffects, TextFill, TextOutline};
+
+use crate::units::{int, measure};
+use crate::xml::El;
+
+/// Read one `w14:` run property into `fx`; false when `e` isn't one.
+pub(crate) fn read(e: &El, theme: &[Rgb], fx: &mut TextEffects) -> bool {
+    match e.name.as_str() {
+        "w14:textFill" => fx.fill = fill(e, theme),
+        "w14:textOutline" => {
+            let (color, transparency) = match e.els().find(|c| matches!(c.name.as_str(), "w14:solidFill" | "w14:gradFill" | "w14:noFill")) {
+                Some(f) if f.name == "w14:noFill" => (None, 0.0),
+                Some(f) => match fill(f, theme) {
+                    Some(TextFill::Solid { color, transparency }) => (Some(color), transparency),
+                    Some(t) => (t.main_color(), 0.0),
+                    None => (None, 0.0),
+                },
+                None => (Some(Rgb::BLACK), 0.0),
+            };
+            fx.outline = Some(TextOutline { color, width: emu(e, "w14:w"), transparency });
+        }
+        "w14:shadow" => {
+            let (color, transparency) = color(e, theme).unwrap_or((Rgb::BLACK, 60.0));
+            fx.shadow = Some(
+                Shadow {
+                    color,
+                    transparency,
+                    blur: emu(e, "w14:blurRad"),
+                    distance: emu(e, "w14:dist"),
+                    angle: angle(e, "w14:dir"),
+                    rot_with_shape: false,
+                }
+                .sanitized(),
+            );
+        }
+        "w14:glow" => {
+            let (color, transparency) = color(e, theme).unwrap_or((Glow::default().color, 60.0));
+            fx.glow = Some(Glow { color, size: emu(e, "w14:rad"), transparency }.sanitized()).filter(|g| g.size > 0.0);
+        }
+        "w14:reflection" => {
+            // Start opacity and the end position of the fade (both 1000ths of a percent).
+            let pct = |n: &str, d: f32| e.attr(n).and_then(int).map_or(d, |v| v.clamp(0, 100_000) as f32 / 1000.0);
+            fx.reflection = Some(Reflection {
+                transparency: 100.0 - pct("w14:stA", 50.0),
+                size: pct("w14:endPos", 50.0),
+                distance: emu(e, "w14:dist"),
+                blur: emu(e, "w14:blurRad"),
+            });
+        }
+        _ => return false,
+    }
+    true
+}
+
+fn emu(e: &El, n: &str) -> f32 {
+    e.attr(n).and_then(|v| measure(v, 12_700.0)).filter(|v| v.is_finite()).unwrap_or(0.0).clamp(0.0, 2000.0)
+}
+
+fn angle(e: &El, n: &str) -> f32 {
+    e.attr(n).and_then(int).map_or(0.0, |v| v.rem_euclid(21_600_000) as f32 / 60_000.0)
+}
+
+/// A fill element (`w14:noFill`, `w14:solidFill`, `w14:gradFill`), or the one inside `e`.
+fn fill(e: &El, theme: &[Rgb]) -> Option<TextFill> {
+    let f = if matches!(e.name.as_str(), "w14:noFill" | "w14:solidFill" | "w14:gradFill") {
+        e
+    } else {
+        e.els().find(|c| matches!(c.name.as_str(), "w14:noFill" | "w14:solidFill" | "w14:gradFill"))?
+    };
+    match f.name.as_str() {
+        "w14:noFill" => Some(TextFill::None),
+        "w14:solidFill" => color(f, theme).map(|(color, transparency)| TextFill::Solid { color, transparency }),
+        _ => {
+            let stops: Vec<GradStop> = f
+                .child("w14:gsLst")
+                .into_iter()
+                .flat_map(|l| l.children("w14:gs"))
+                .take(MAX_STOPS)
+                .filter_map(|gs| {
+                    let (color, transparency) = color(gs, theme)?;
+                    let pos = gs.attr("w14:pos").and_then(int).map_or(0.0, |v| v.clamp(0, 100_000) as f32 / 1000.0);
+                    Some(GradStop { pos, color, transparency })
+                })
+                .collect();
+            let angle = f.child("w14:lin").map_or(90.0, |l| angle(l, "w14:ang"));
+            TextFill::Gradient { stops, angle }.sanitized()
+        }
+    }
+}
+
+/// The colour element inside `e` (`w14:srgbClr`, `w14:schemeClr`) with its modifiers, and its
+/// transparency (percent, from `w14:alpha`).
+fn color(e: &El, theme: &[Rgb]) -> Option<(Rgb, f32)> {
+    let c = e.els().find(|c| matches!(c.name.as_str(), "w14:srgbClr" | "w14:schemeClr"))?;
+    let val = c.attr("w14:val")?;
+    let mut rgb = if c.name == "w14:srgbClr" { Rgb::parse(val)? } else { super::drawing_color::scheme(val, theme)? };
+    let mut transparency = 0.0;
+    for m in c.els() {
+        let v = m.attr("w14:val").and_then(int).map_or(0.0, |v| (v as f64 / 100_000.0).clamp(-10.0, 10.0));
+        match m.name.as_str() {
+            "w14:lumMod" => rgb = super::drawing_color::lum(rgb, |l| l * v),
+            "w14:lumOff" => rgb = super::drawing_color::lum(rgb, |l| l + v),
+            // Unlike DrawingML's `a:alpha`, `w14:alpha` is the transparency.
+            "w14:alpha" => transparency = (v.clamp(0.0, 1.0) * 100.0) as f32,
+            _ => {}
+        }
+    }
+    Some((rgb, transparency))
+}
diff --git a/crates/docx/src/smart_art.rs b/crates/docx/src/smart_art.rs
new file mode 100644
index 0000000000..22eda0567c
--- /dev/null
+++ b/crates/docx/src/smart_art.rs
@@ -0,0 +1,1164 @@
+//! SmartArt graphics WordCraft makes ([`SmartArtSpec`]) as diagram parts (ECMA-376 Part 1 §21.4)
+//! and back.
+//!
+//! WordCraft lays a graphic out with its own algorithms ([`layout`]: blocks, steps with arrows,
+//! a cycle, a tree, a pyramid, a radial, a matrix, overlapping circles) and writes five parts:
+//! - the data model ([`data_xml`], `dgm:dataModel`): the document point, a node point per item
+//!   with its text, and connections that give each item its parent;
+//! - a layout definition ([`layout_xml`]), a quick style ([`quick_style_xml`]) and a colour
+//!   definition ([`colors_xml`]) of our own, named by the identifiers ECMA-376 applications use
+//!   for the matching built-in layouts, styles and colours;
+//! - the drawing ([`drawing_xml`], `dsp:drawing`): every shape already placed, so any reader
+//!   shows the graphic as WordCraft laid it out. WordCraft draws its own graphics from that same
+//!   drawing ([`smart_art_items`]).
+//!
+//! [`spec_of`] turns a data part back into the model only when writing that model again gives
+//! the same markup: a diagram another program made or changed stays read-only.
+
+use wordcraft_doc::graphic::GraphicItem;
+use wordcraft_doc::props::Rgb;
+use wordcraft_doc::smart_art::{MAX_ITEMS, SmartArtColors, SmartArtItem, SmartArtLayout, SmartArtSpec};
+
+use crate::read::diagram::{text_width, wrap};
+use crate::xml::{self, El, MAX_DEPTH, Node, W};
+
+const NS_DGM: &str = "http://schemas.openxmlformats.org/drawingml/2006/diagram";
+const NS_DSP: &str = "http://schemas.microsoft.com/office/drawing/2008/diagram";
+const NS_A: &str = "http://schemas.openxmlformats.org/drawingml/2006/main";
+const NS_R: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
+/// `a:graphicData` URI of a diagram.
+pub(crate) const DIAGRAM_URI: &str = "http://schemas.openxmlformats.org/drawingml/2006/diagram";
+/// Content types of the five parts.
+pub(crate) const DATA_CT: &str = "application/vnd.openxmlformats-officedocument.drawingml.diagramData+xml";
+pub(crate) const LAYOUT_CT: &str = "application/vnd.openxmlformats-officedocument.drawingml.diagramLayout+xml";
+pub(crate) const STYLE_CT: &str = "application/vnd.openxmlformats-officedocument.drawingml.diagramStyle+xml";
+pub(crate) const COLORS_CT: &str = "application/vnd.openxmlformats-officedocument.drawingml.diagramColors+xml";
+pub(crate) const DRAWING_CT: &str = "application/vnd.ms-office.drawingml.diagramDrawing+xml";
+/// The extension a data model names its drawing in (ECMA-376 extension list, `dsp:dataModelExt`).
+const DRAWING_EXT_URI: &str = "http://schemas.microsoft.com/office/drawing/2008/diagram";
+const QUICK_STYLE_ID: &str = "urn:microsoft.com/office/officeart/2005/8/quickstyle/simple1";
+const EMU_PT: f32 = 12_700.0;
+/// Line height as a multiple of the font size (as the drawing reader stacks lines).
+const LINE: f32 = 1.2;
+/// Largest and smallest text size a graphic is given, points.
+const MAX_SIZE: f32 = 24.0;
+const MIN_SIZE: f32 = 5.0;
+/// A sub-item's text size against its item's.
+const CHILD: f32 = 0.8;
+/// Model ids of the drawing's shapes start here (the data model's points are below).
+const SHAPE_IDS: usize = 0x10000;
+
+/// The layout's identifier and its gallery category.
+fn layout_id(l: SmartArtLayout) -> (&'static str, &'static str) {
+    match l {
+        SmartArtLayout::BasicList => ("urn:microsoft.com/office/officeart/2005/8/layout/default", "list"),
+        SmartArtLayout::Process => ("urn:microsoft.com/office/officeart/2005/8/layout/process1", "process"),
+        SmartArtLayout::Cycle => ("urn:microsoft.com/office/officeart/2005/8/layout/cycle2", "cycle"),
+        SmartArtLayout::Hierarchy => ("urn:microsoft.com/office/officeart/2005/8/layout/hierarchy1", "hierarchy"),
+        SmartArtLayout::Pyramid => ("urn:microsoft.com/office/officeart/2005/8/layout/pyramid1", "pyramid"),
+        SmartArtLayout::Radial => ("urn:microsoft.com/office/officeart/2005/8/layout/radial1", "cycle"),
+        SmartArtLayout::Matrix => ("urn:microsoft.com/office/officeart/2005/8/layout/matrix3", "matrix"),
+        SmartArtLayout::Venn => ("urn:microsoft.com/office/officeart/2005/8/layout/venn1", "relationship"),
+    }
+}
+
+/// The colour definition's identifier and category.
+fn colors_id(c: SmartArtColors) -> (String, String) {
+    match c {
+        SmartArtColors::Colorful => ("urn:microsoft.com/office/officeart/2005/8/colors/colorful1".into(), "colorful".into()),
+        _ => {
+            let n = c.accent(0);
+            (format!("urn:microsoft.com/office/officeart/2005/8/colors/accent{n}_2"), format!("accent{n}"))
+        }
+    }
+}
+
+/// Model id number `n` as the GUID form ECMA-376 model ids take.
+fn model_id(n: usize) -> String {
+    format!("{{5743A57A-0000-4000-8000-{n:012X}}}")
+}
+
+// ---- layout ----
+
+/// What a shape is filled or outlined with.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum Paint {
+    None,
+    /// Theme accent `n` (1–6), lightened to `tint` (thousandths of a percent kept) when set.
+    Accent(usize, Option<u32>),
+    /// The theme's light background colour.
+    Light,
+}
+
+/// One shape of a laid-out graphic, in points from the graphic's top-left corner.
+#[derive(Clone, Debug)]
+struct Sh {
+    prst: &'static str,
+    b: [f32; 4],
+    /// Clockwise turn, degrees.
+    rot: f32,
+    flip_h: bool,
+    /// The preset's `adj` value, when not its default.
+    adj: Option<i64>,
+    fill: Paint,
+    /// Fill opacity (thousandths of a percent) for readers that blend.
+    alpha: Option<u32>,
+    line: Paint,
+    line_w: f32,
+    /// Paragraphs: text and whether it's a sub-item (smaller, bulleted, left-aligned).
+    text: Vec<(String, bool)>,
+    /// Where the text goes.
+    tb: [f32; 4],
+    dark_text: bool,
+}
+
+impl Sh {
+    /// A filled node shape with a thin light outline.
+    fn node(prst: &'static str, b: [f32; 4], accent: usize) -> Sh {
+        Sh {
+            prst,
+            b,
+            rot: 0.0,
+            flip_h: false,
+            adj: None,
+            fill: Paint::Accent(accent, None),
+            alpha: None,
+            line: Paint::Light,
+            line_w: 1.0,
+            text: Vec::new(),
+            tb: inset(b, 0.06),
+            dark_text: false,
+        }
+    }
+
+    /// A straight connector from (`x0`, `y0`) to (`x1`, `y1`).
+    fn line(x0: f32, y0: f32, x1: f32, y1: f32, accent: usize) -> Sh {
+        let b = [x0.min(x1), y0.min(y1), (x1 - x0).abs(), (y1 - y0).abs()];
+        Sh {
+            prst: "line",
+            b,
+            rot: 0.0,
+            flip_h: (x1 - x0) * (y1 - y0) < 0.0,
+            adj: None,
+            fill: Paint::None,
+            alpha: None,
+            line: Paint::Accent(accent, Some(60_000)),
+            line_w: 1.5,
+            text: Vec::new(),
+            tb: b,
+            dark_text: false,
+        }
+    }
+
+    fn with_text(mut self, text: Vec<(String, bool)>) -> Sh {
+        self.text = text;
+        self
+    }
+
+    fn text_box(mut self, tb: [f32; 4]) -> Sh {
+        self.tb = tb;
+        self
+    }
+}
+
+/// `b` shrunk by `f` of its width and height on every side.
+fn inset(b: [f32; 4], f: f32) -> [f32; 4] {
+    [b[0] + b[2] * f, b[1] + b[3] * f, b[2] * (1.0 - 2.0 * f), b[3] * (1.0 - 2.0 * f)]
+}
+
+/// The inscribed square's share of a circle's box to leave on each side.
+const ROUND_INSET: f32 = 0.15;
+
+/// The text of item `i`: its own line, then the items under it as bulleted sub-items.
+fn paras(spec: &SmartArtSpec, i: usize, with_children: bool) -> Vec<(String, bool)> {
+    let mut out = vec![(spec.items.get(i).map(|it| it.text.clone()).unwrap_or_default(), false)];
+    if with_children {
+        for j in spec.descendants(i) {
+            if let Some(it) = spec.items.get(j) {
+                out.push((format!("• {}", it.text), true));
+            }
+        }
+    }
+    out
+}
+
+/// The top-level items.
+fn tops(spec: &SmartArtSpec) -> Vec<usize> {
+    spec.items.iter().enumerate().filter(|(_, it)| it.level == 0).map(|(i, _)| i).collect()
+}
+
+/// The shapes of `spec` laid out in a `w` × `h` points box, back to front.
+fn layout(spec: &SmartArtSpec, w: f32, h: f32) -> Vec<Sh> {
+    let ok = |v: f32| if v.is_finite() { v.clamp(0.0, 20_000.0) } else { 0.0 };
+    let (w, h) = (ok(w), ok(h));
+    if spec.items.is_empty() || w < 1.0 || h < 1.0 {
+        return Vec::new();
+    }
+    match spec.layout {
+        SmartArtLayout::BasicList => basic_list(spec, w, h),
+        SmartArtLayout::Process => process(spec, w, h),
+        SmartArtLayout::Cycle => cycle(spec, w, h),
+        SmartArtLayout::Hierarchy => hierarchy(spec, w, h),
+        SmartArtLayout::Pyramid => pyramid(spec, w, h),
+        SmartArtLayout::Radial => radial(spec, w, h),
+        SmartArtLayout::Matrix => matrix(spec, w, h),
+        SmartArtLayout::Venn => venn(spec, w, h),
+    }
+}
+
+/// Blocks of 3:2 in rows, as large as fit; the last row centred.
+fn basic_list(spec: &SmartArtSpec, w: f32, h: f32) -> Vec<Sh> {
+    let tops = tops(spec);
+    let n = tops.len().max(1);
+    let size = |c: usize| {
+        let r = n.div_ceil(c);
+        let bw = (w / c as f32 * 0.9).min(h / r as f32 * 0.9 * 1.5);
+        (bw, bw / 1.5)
+    };
+    let cols = (1..=n).max_by(|a, b| (size(*a).0).total_cmp(&size(*b).0)).unwrap_or(1);
+    let rows = n.div_ceil(cols);
+    let (bw, bh) = size(cols);
+    let (gx, gy) = (bw * 0.1, bh * 0.1);
+    let y0 = (h - (rows as f32 * bh + (rows - 1) as f32 * gy)) / 2.0;
+    let mut out = Vec::new();
+    for (k, &i) in tops.iter().enumerate() {
+        let (r, c) = (k / cols, k % cols);
+        let in_row = if r + 1 == rows { n - r * cols } else { cols };
+        let x0 = (w - (in_row as f32 * bw + (in_row - 1) as f32 * gx)) / 2.0;
+        let b = [x0 + c as f32 * (bw + gx), y0 + r as f32 * (bh + gy), bw, bh];
+        out.push(Sh::node("rect", b, spec.colors.accent(k)).with_text(paras(spec, i, true)));
+    }
+    out
+}
+
+/// Steps left to right with an arrow in each gap.
+fn process(spec: &SmartArtSpec, w: f32, h: f32) -> Vec<Sh> {
+    let tops = tops(spec);
+    let n = tops.len().max(1) as f32;
+    const GAP: f32 = 0.45;
+    let nw = w / (n + (n - 1.0) * GAP);
+    let nh = (nw * 0.6).min(h * 0.9);
+    let y = (h - nh) / 2.0;
+    let gap = nw * GAP;
+    let mut out = Vec::new();
+    for (k, _) in tops.iter().enumerate().skip(1) {
+        let gx = k as f32 * (nw + gap) - gap;
+        let (aw, ah) = (gap * 0.62, (nh * 0.35).min(gap * 0.7));
+        let mut a = Sh::node("rightArrow", [gx + (gap - aw) / 2.0, h / 2.0 - ah / 2.0, aw, ah], spec.colors.accent(k - 1));
+        a.fill = Paint::Accent(spec.colors.accent(k - 1), Some(60_000));
+        a.line = Paint::None;
+        out.push(a);
+    }
+    for (k, &i) in tops.iter().enumerate() {
+        let b = [k as f32 * (nw + gap), y, nw, nh];
+        out.push(Sh::node("roundRect", b, spec.colors.accent(k)).with_text(paras(spec, i, true)));
+    }
+    out
+}
+
+/// The angle (degrees, clockwise from three o'clock) of place `k` of `n` round a circle, the
+/// first at twelve o'clock.
+fn angle(k: usize, n: usize) -> f32 {
+    -90.0 + 360.0 * k as f32 / n.max(1) as f32
+}
+
+/// The point at `r` from (`cx`, `cy`) at `deg`.
+fn polar(cx: f32, cy: f32, r: f32, deg: f32) -> (f32, f32) {
+    let (s, c) = deg.to_radians().sin_cos();
+    (cx + r * c, cy + r * s)
+}
+
+/// Circles round a circle, clockwise from the top, with a curved-path arrow between each.
+fn cycle(spec: &SmartArtSpec, w: f32, h: f32) -> Vec<Sh> {
+    let tops = tops(spec);
+    let n = tops.len().max(1);
+    let m = w.min(h);
+    let (cx, cy) = (w / 2.0, h / 2.0);
+    let step = (std::f32::consts::PI / n as f32).sin();
+    let mut d = m * 0.32;
+    for _ in 0..4 {
+        let r = (m - d) / 2.0;
+        d = if n == 1 { m * 0.5 } else { (m * 0.32).min(2.0 * r * step * 0.62) };
+    }
+    let r = (m - d) / 2.0;
+    let mut out = Vec::new();
+    if n > 1 {
+        let chord = 2.0 * r * step;
+        let len = (chord - d) * 0.6;
+        if len > 2.0 {
+            let thick = (len * 0.6).min(d * 0.25);
+            for k in 0..n {
+                let mid = angle(k, n) + 180.0 / n as f32;
+                let (x, y) = polar(cx, cy, r, mid);
+                let mut a = Sh::node("rightArrow", [x - len / 2.0, y - thick / 2.0, len, thick], spec.colors.accent(k));
+                a.rot = (mid + 90.0).rem_euclid(360.0);
+                a.fill = Paint::Accent(spec.colors.accent(k), Some(60_000));
+                a.line = Paint::None;
+                out.push(a);
+            }
+        }
+    }
+    for (k, &i) in tops.iter().enumerate() {
+        let (x, y) = if n == 1 { (cx, cy) } else { polar(cx, cy, r, angle(k, n)) };
+        let b = [x - d / 2.0, y - d / 2.0, d, d];
+        out.push(Sh::node("ellipse", b, spec.colors.accent(k)).with_text(paras(spec, i, true)).text_box(inset(b, ROUND_INSET)));
+    }
+    out
+}
+
+/// A tree, a row per level: each item centred over the items under it, joined by elbow lines.
+fn hierarchy(spec: &SmartArtSpec, w: f32, h: f32) -> Vec<Sh> {
+    let n = spec.items.len();
+    let parents = spec.parents();
+    let mut kids: Vec<Vec<usize>> = vec![Vec::new(); n];
+    let mut roots = Vec::new();
+    for (i, p) in parents.iter().enumerate() {
+        match p.and_then(|p| kids.get_mut(p)) {
+            Some(k) => k.push(i),
+            None => roots.push(i),
+        }
+    }
+    // Leaves under each item (children come after their parent, so from the end).
+    let mut leaves = vec![1usize; n];
+    for i in (0..n).rev() {
+        let sum: usize = kids.get(i).map_or(0, |k| k.iter().map(|&c| leaves.get(c).copied().unwrap_or(1)).sum());
+        if sum > 0
+            && let Some(l) = leaves.get_mut(i)
+        {
+            *l = sum;
+        }
+    }
+    let depth = spec.items.iter().map(|it| usize::from(it.level)).max().unwrap_or(0) + 1;
+    let total: usize = roots.iter().map(|&r| leaves.get(r).copied().unwrap_or(1)).sum::<usize>().max(1);
+    let unit = w / total as f32;
+    let rh = h / depth as f32;
+    let nw = (unit * 0.88).min(rh * 0.62 * 1.8);
+    let nh = (rh * 0.62).min(nw * 0.8);
+    let mut start = vec![0.0f32; n];
+    let mut at = 0.0;
+    for &r in &roots {
+        if let Some(s) = start.get_mut(r) {
+            *s = at;
+        }
+        at += leaves.get(r).copied().unwrap_or(1) as f32 * unit;
+    }
+    for i in 0..n {
+        let mut at = start.get(i).copied().unwrap_or(0.0);
+        for &k in kids.get(i).map(Vec::as_slice).unwrap_or(&[]) {
+            if let Some(s) = start.get_mut(k) {
+                *s = at;
+            }
+            at += leaves.get(k).copied().unwrap_or(1) as f32 * unit;
+        }
+    }
+    let cx = |i: usize| start.get(i).copied().unwrap_or(0.0) + leaves.get(i).copied().unwrap_or(1) as f32 * unit / 2.0;
+    let top = |i: usize| spec.items.get(i).map_or(0.0, |it| f32::from(it.level) * rh + (rh - nh) / 2.0);
+    let mut out = Vec::new();
+    for i in 0..n {
+        let Some(ks) = kids.get(i).filter(|k| !k.is_empty()) else { continue };
+        let accent = spec.colors.accent(i);
+        let (px, pb) = (cx(i), top(i) + nh);
+        let ct = ks.first().map_or(pb, |&k| top(k));
+        let mid = (pb + ct) / 2.0;
+        out.push(Sh::line(px, pb, px, mid, accent));
+        let xs: Vec<f32> = ks.iter().map(|&k| cx(k)).collect();
+        let (lo, hi) = xs.iter().fold((px, px), |(lo, hi), &x| (lo.min(x), hi.max(x)));
+        if hi - lo > 0.5 {
+            out.push(Sh::line(lo, mid, hi, mid, accent));
+        }
+        for x in xs {
+            out.push(Sh::line(x, mid, x, ct, accent));
+        }
+    }
+    for i in 0..n {
+        let b = [cx(i) - nw / 2.0, top(i), nw, nh];
+        out.push(Sh::node("roundRect", b, spec.colors.accent(i)).with_text(paras(spec, i, false)));
+    }
+    out
+}
+
+/// Bands stacked into a triangle: the first item at the narrow top.
+fn pyramid(spec: &SmartArtSpec, w: f32, h: f32) -> Vec<Sh> {
+    let tops = tops(spec);
+    let n = tops.len().max(1) as f32;
+    let tw = w.min(h * 1.3);
+    let x0 = (w - tw) / 2.0;
+    let bh = h / n;
+    let mut out = Vec::new();
+    for (k, &i) in tops.iter().enumerate() {
+        let (top_w, bot_w) = (tw * k as f32 / n, tw * (k as f32 + 1.0) / n);
+        let b = [x0 + (tw - bot_w) / 2.0, k as f32 * bh, bot_w, bh];
+        let accent = spec.colors.accent(k);
+        let sh = if k == 0 {
+            let tb = [b[0] + bot_w * 0.22, b[1] + bh * 0.4, bot_w * 0.56, bh * 0.56];
+            Sh::node("triangle", b, accent).text_box(tb)
+        } else {
+            let inset_x = (bot_w - top_w) / 2.0;
+            let ss = bot_w.min(bh).max(0.01);
+            let mut s = Sh::node("trapezoid", b, accent);
+            s.adj = Some((inset_x / ss * 100_000.0).round().clamp(0.0, 10_000_000.0) as i64);
+            let mid_w = (top_w + bot_w) / 2.0 * 0.8;
+            s.text_box([w / 2.0 - mid_w / 2.0, b[1] + bh * 0.08, mid_w, bh * 0.84])
+        };
+        out.push(sh.with_text(paras(spec, i, true)));
+    }
+    out
+}
+
+/// The first item in the middle; the items under it (and any later top-level items) around it,
+/// each joined to the middle by a line.
+fn radial(spec: &SmartArtSpec, w: f32, h: f32) -> Vec<Sh> {
+    let n_items = spec.items.len();
+    let parents = spec.parents();
+    let spokes: Vec<usize> = (1..n_items).filter(|&i| matches!(parents.get(i), Some(Some(0)) | Some(None))).collect();
+    let n = spokes.len();
+    let m = w.min(h);
+    let (cx, cy) = (w / 2.0, h / 2.0);
+    let mut out = Vec::new();
+    if n == 0 {
+        let d = m * 0.5;
+        let b = [cx - d / 2.0, cy - d / 2.0, d, d];
+        out.push(Sh::node("ellipse", b, spec.colors.accent(0)).with_text(paras(spec, 0, false)).text_box(inset(b, ROUND_INSET)));
+        return out;
+    }
+    let step = if n == 1 { 1.0 } else { (std::f32::consts::PI / n as f32).sin() };
+    let mut ds = m * 0.24;
+    for _ in 0..4 {
+        let r = (m - ds) / 2.0;
+        ds = (m * 0.24).min(2.0 * r * step * 0.85);
+    }
+    let r = (m - ds) / 2.0;
+    let dc = (m * 0.36).min(2.0 * (r - ds / 2.0 - m * 0.03)).max(m * 0.05);
+    let at = |k: usize| polar(cx, cy, r, angle(k, n));
+    for k in 0..n {
+        let (x, y) = at(k);
+        out.push(Sh::line(cx, cy, x, y, spec.colors.accent(0)));
+    }
+    let bc = [cx - dc / 2.0, cy - dc / 2.0, dc, dc];
+    out.push(Sh::node("ellipse", bc, spec.colors.accent(0)).with_text(paras(spec, 0, false)).text_box(inset(bc, ROUND_INSET)));
+    for (k, &i) in spokes.iter().enumerate() {
+        let (x, y) = at(k);
+        let b = [x - ds / 2.0, y - ds / 2.0, ds, ds];
+        out.push(Sh::node("ellipse", b, spec.colors.accent(k + 1)).with_text(paras(spec, i, true)).text_box(inset(b, ROUND_INSET)));
+    }
+    out
+}
+
+/// Quadrants of a square (more items: a larger grid).
+fn matrix(spec: &SmartArtSpec, w: f32, h: f32) -> Vec<Sh> {
+    let tops = tops(spec);
+    let n = tops.len().max(1);
+    let cols = (1..=n).find(|c| c * c >= n).unwrap_or(n).max(1);
+    let rows = n.div_ceil(cols);
+    let cell = (w / cols as f32).min(h / rows as f32);
+    let gap = cell * 0.04;
+    let (x0, y0) = ((w - cols as f32 * cell) / 2.0, (h - rows as f32 * cell) / 2.0);
+    let mut out = Vec::new();
+    for (k, &i) in tops.iter().enumerate() {
+        let (r, c) = (k / cols, k % cols);
+        let b = [x0 + c as f32 * cell + gap / 2.0, y0 + r as f32 * cell + gap / 2.0, cell - gap, cell - gap];
+        out.push(Sh::node("roundRect", b, spec.colors.accent(k)).with_text(paras(spec, i, true)).text_box(inset(b, 0.1)));
+    }
+    out
+}
+
+/// Overlapping circles round the middle; each one's text on its outer side.
+fn venn(spec: &SmartArtSpec, w: f32, h: f32) -> Vec<Sh> {
+    let tops = tops(spec);
+    let n = tops.len().max(1);
+    let m = w.min(h);
+    let (cx, cy) = (w / 2.0, h / 2.0);
+    // Ring radius against circle radius: neighbours' centres 1.5 radii apart.
+    let k = if n == 1 { 0.0 } else { (0.75 / (std::f32::consts::PI / n as f32).sin()).max(0.6) };
+    let r = m / (2.0 * (k + 1.0));
+    let start = if n == 2 { 180.0 } else { -90.0 };
+    let place = |j: usize| -> (f32, f32, f32) {
+        let deg = start + 360.0 * j as f32 / n as f32;
+        let (x, y) = polar(cx, cy, r * k, deg);
+        (x, y, deg)
+    };
+    let mut out = Vec::new();
+    for (j, _) in tops.iter().enumerate() {
+        let (x, y, _) = place(j);
+        let mut s = Sh::node("ellipse", [x - r, y - r, 2.0 * r, 2.0 * r], spec.colors.accent(j));
+        s.fill = Paint::Accent(spec.colors.accent(j), Some(40_000));
+        s.alpha = Some(60_000);
+        s.line = Paint::None;
+        out.push(s);
+    }
+    // Every outline over every fill, so each circle shows whole.
+    for (j, _) in tops.iter().enumerate() {
+        let (x, y, _) = place(j);
+        let mut s = Sh::node("ellipse", [x - r, y - r, 2.0 * r, 2.0 * r], spec.colors.accent(j));
+        s.fill = Paint::None;
+        s.line = Paint::Accent(spec.colors.accent(j), None);
+        s.line_w = 1.5;
+        out.push(s);
+    }
+    for (j, &i) in tops.iter().enumerate() {
+        let (x, y, deg) = place(j);
+        let (tx, ty) = if n == 1 { (x, y) } else { polar(x, y, r * 0.35, deg) };
+        let (bw, bh) = (r * 1.1, r * 0.8);
+        let b = [tx - bw / 2.0, ty - bh / 2.0, bw, bh];
+        let mut s = Sh::node("rect", b, spec.colors.accent(j)).with_text(paras(spec, i, true)).text_box(b);
+        s.fill = Paint::None;
+        s.line = Paint::None;
+        s.dark_text = true;
+        out.push(s);
+    }
+    out
+}
+
+// ---- text ----
+
+/// Whether `paras` fit a `w` × `h` text box at `size` points (sub-items at [`CHILD`] of it).
+fn fits(paras: &[(String, bool)], size: f32, w: f32, h: f32) -> bool {
+    let mut total = 0.0;
+    for (t, child) in paras {
+        let s = if *child { child_size(size) } else { size };
+        if t.split_whitespace().any(|word| text_width(word, s) > w) {
+            return false;
+        }
+        let lines = wrap(t, s, w, 10_000).len().max(1);
+        total += lines as f32 * s * LINE;
+    }
+    total <= h
+}
+
+fn child_size(size: f32) -> f32 {
+    (size * CHILD * 2.0).round() / 2.0
+}
+
+/// The largest text size (half points, [`MIN_SIZE`]–[`MAX_SIZE`]) at which every shape's text fits.
+fn text_size(shapes: &[Sh]) -> f32 {
+    let mut size = MAX_SIZE;
+    while size > MIN_SIZE && !shapes.iter().filter(|s| !s.text.is_empty()).all(|s| fits(&s.text, size, s.tb[2], s.tb[3])) {
+        size -= 0.5;
+    }
+    size
+}
+
+// ---- parts ----
+
+/// A length in points as EMU text, bounded.
+fn emu(pt: f32) -> String {
+    let v = if pt.is_finite() { (pt * EMU_PT).round() } else { 0.0 };
+    format!("{}", v.clamp(-1.0e9, 1.0e9) as i64)
+}
+
+fn paint(w: &mut W, p: Paint, alpha: Option<u32>) {
+    match p {
+        Paint::None => w.empty("a:noFill", &[]),
+        Paint::Light => {
+            w.open("a:solidFill", &[]);
+            w.empty("a:schemeClr", &[("val", "lt1")]);
+            w.close("a:solidFill");
+        }
+        Paint::Accent(n, tint) => {
+            w.open("a:solidFill", &[]);
+            let val = format!("accent{}", n.clamp(1, 6));
+            if tint.is_none() && alpha.is_none() {
+                w.empty("a:schemeClr", &[("val", &val)]);
+            } else {
+                w.open("a:schemeClr", &[("val", &val)]);
+                if let Some(t) = tint {
+                    w.empty("a:tint", &[("val", &t.to_string())]);
+                }
+                if let Some(a) = alpha {
+                    w.empty("a:alpha", &[("val", &a.to_string())]);
+                }
+                w.close("a:schemeClr");
+            }
+            w.close("a:solidFill");
+        }
+    }
+}
+
+/// The `dsp:drawing` of `spec` laid out `w` × `h` points: its shapes, back to front.
+pub fn drawing_xml(spec: &SmartArtSpec, w: f32, h: f32) -> String {
+    let shapes = layout(spec, w, h);
+    let size = text_size(&shapes);
+    let mut x = W::new();
+    x.open("dsp:drawing", &[("xmlns:dgm", NS_DGM), ("xmlns:dsp", NS_DSP), ("xmlns:a", NS_A)]);
+    x.open("dsp:spTree", &[]);
+    x.open("dsp:nvGrpSpPr", &[]);
+    x.empty("dsp:cNvPr", &[("id", "0"), ("name", "")]);
+    x.empty("dsp:cNvGrpSpPr", &[]);
+    x.close("dsp:nvGrpSpPr");
+    x.empty("dsp:grpSpPr", &[]);
+    for (k, sh) in shapes.iter().enumerate() {
+        shape_xml(&mut x, sh, &model_id(SHAPE_IDS + k), size);
+    }
+    x.close("dsp:spTree");
+    x.close("dsp:drawing");
+    x.s
+}
+
+fn shape_xml(x: &mut W, sh: &Sh, id: &str, size: f32) {
+    x.open("dsp:sp", &[("modelId", id)]);
+    x.open("dsp:nvSpPr", &[]);
+    x.empty("dsp:cNvPr", &[("id", "0"), ("name", "")]);
+    x.empty("dsp:cNvSpPr", &[]);
+    x.close("dsp:nvSpPr");
+    x.open("dsp:spPr", &[]);
+    let rot = ((sh.rot.rem_euclid(360.0) * 60_000.0).round() as i64).to_string();
+    let mut attrs: Vec<(&str, &str)> = Vec::new();
+    if sh.rot != 0.0 {
+        attrs.push(("rot", &rot));
+    }
+    if sh.flip_h {
+        attrs.push(("flipH", "1"));
+    }
+    x.open("a:xfrm", &attrs);
+    x.empty("a:off", &[("x", &emu(sh.b[0])), ("y", &emu(sh.b[1]))]);
+    x.empty("a:ext", &[("cx", &emu(sh.b[2].max(0.0))), ("cy", &emu(sh.b[3].max(0.0)))]);
+    x.close("a:xfrm");
+    x.open("a:prstGeom", &[("prst", sh.prst)]);
+    match sh.adj {
+        Some(v) => {
+            x.open("a:avLst", &[]);
+            x.empty("a:gd", &[("name", "adj"), ("fmla", &format!("val {v}"))]);
+            x.close("a:avLst");
+        }
+        None => x.empty("a:avLst", &[]),
+    }
+    x.close("a:prstGeom");
+    paint(x, sh.fill, sh.alpha);
+    if sh.line != Paint::None && sh.line_w > 0.0 {
+        x.open("a:ln", &[("w", &emu(sh.line_w))]);
+        paint(x, sh.line, None);
+        x.close("a:ln");
+    } else {
+        x.open("a:ln", &[]);
+        x.empty("a:noFill", &[]);
+        x.close("a:ln");
+    }
+    x.close("dsp:spPr");
+    let text_clr = if sh.dark_text { "tx1" } else { "lt1" };
+    x.open("dsp:style", &[]);
+    for (name, idx) in [("a:lnRef", "2"), ("a:fillRef", "1"), ("a:effectRef", "0")] {
+        x.open(name, &[("idx", idx)]);
+        x.empty("a:scrgbClr", &[("r", "0"), ("g", "0"), ("b", "0")]);
+        x.close(name);
+    }
+    x.open("a:fontRef", &[("idx", "minor")]);
+    x.empty("a:schemeClr", &[("val", text_clr)]);
+    x.close("a:fontRef");
+    x.close("dsp:style");
+    if !sh.text.is_empty() {
+        x.open("dsp:txBody", &[]);
+        x.open(
+            "a:bodyPr",
+            &[
+                ("spcFirstLastPara", "0"),
+                ("vert", "horz"),
+                ("wrap", "square"),
+                ("lIns", "0"),
+                ("tIns", "0"),
+                ("rIns", "0"),
+                ("bIns", "0"),
+                ("numCol", "1"),
+                ("spcCol", "0"),
+                ("anchor", "ctr"),
+                ("anchorCtr", "0"),
+            ],
+        );
+        x.empty("a:noAutofit", &[]);
+        x.close("a:bodyPr");
+        x.empty("a:lstStyle", &[]);
+        for (t, child) in &sh.text {
+            let s = if *child { child_size(size) } else { size };
+            x.open("a:p", &[]);
+            x.open("a:pPr", &[("lvl", if *child { "1" } else { "0" }), ("algn", if *child { "l" } else { "ctr" })]);
+            x.empty("a:buNone", &[]);
+            x.close("a:pPr");
+            if t.is_empty() {
+                x.empty("a:endParaRPr", &[("lang", "en-US"), ("sz", &((s * 100.0).round() as i64).to_string())]);
+            } else {
+                x.open("a:r", &[]);
+                x.open("a:rPr", &[("lang", "en-US"), ("sz", &((s * 100.0).round() as i64).to_string())]);
+                x.open("a:solidFill", &[]);
+                x.empty("a:schemeClr", &[("val", text_clr)]);
+                x.close("a:solidFill");
+                x.close("a:rPr");
+                x.leaf("a:t", &[], t);
+                x.close("a:r");
+            }
+            x.close("a:p");
+        }
+        x.close("dsp:txBody");
+        x.open("dsp:txXfrm", &[]);
+        x.empty("a:off", &[("x", &emu(sh.tb[0])), ("y", &emu(sh.tb[1]))]);
+        x.empty("a:ext", &[("cx", &emu(sh.tb[2].max(0.0))), ("cy", &emu(sh.tb[3].max(0.0)))]);
+        x.close("dsp:txXfrm");
+    }
+    x.close("dsp:sp");
+}
+
+/// What `spec` draws as, `w` × `h` points, in the colours of `theme`: its drawing part, read the
+/// way SmartArt drawings from files are.
+pub fn smart_art_items(spec: &SmartArtSpec, theme: &[Rgb], w: f32, h: f32) -> Vec<GraphicItem> {
+    match xml::parse(drawing_xml(spec, w, h).as_bytes()) {
+        Ok(d) => crate::read::diagram::diagram_items(&d, theme, w, h, &mut |_| None),
+        Err(_) => Vec::new(),
+    }
+}
+
+/// Ids of the points and connections of item `i`: (node, connection, parent transition, sibling
+/// transition).
+fn item_ids(i: usize) -> (String, String, String, String) {
+    let b = 1 + 4 * i;
+    (model_id(b), model_id(b + 1), model_id(b + 2), model_id(b + 3))
+}
+
+/// An empty point text body.
+fn empty_t(w: &mut W) {
+    w.open("dgm:t", &[]);
+    w.empty("a:bodyPr", &[]);
+    w.empty("a:lstStyle", &[]);
+    w.open("a:p", &[]);
+    w.empty("a:endParaRPr", &[("lang", "en-US")]);
+    w.close("a:p");
+    w.close("dgm:t");
+}
+
+/// The data part (`dgm:dataModel`) of `spec`; its drawing is the story part's relationship
+/// `drawing_rel`.
+pub fn data_xml(spec: &SmartArtSpec, drawing_rel: &str) -> String {
+    let (lo, lo_cat) = layout_id(spec.layout);
+    let (cs, cs_cat) = colors_id(spec.colors);
+    let doc = model_id(0);
+    let mut w = W::new();
+    w.open("dgm:dataModel", &[("xmlns:dgm", NS_DGM), ("xmlns:a", NS_A)]);
+    w.open("dgm:ptLst", &[]);
+    w.open("dgm:pt", &[("modelId", &doc), ("type", "doc")]);
+    w.empty(
+        "dgm:prSet",
+        &[("loTypeId", lo), ("loCatId", lo_cat), ("qsTypeId", QUICK_STYLE_ID), ("qsCatId", "simple"), ("csTypeId", &cs), ("csCatId", &cs_cat)],
+    );
+    w.empty("dgm:spPr", &[]);
+    empty_t(&mut w);
+    w.close("dgm:pt");
+    for (i, it) in spec.items.iter().enumerate() {
+        let (node, cxn, par, sib) = item_ids(i);
+        w.open("dgm:pt", &[("modelId", &node)]);
+        w.empty("dgm:prSet", &[]);
+        w.empty("dgm:spPr", &[]);
+        w.open("dgm:t", &[]);
+        w.empty("a:bodyPr", &[]);
+        w.empty("a:lstStyle", &[]);
+        w.open("a:p", &[]);
+        w.open("a:r", &[]);
+        w.empty("a:rPr", &[("lang", "en-US")]);
+        w.leaf("a:t", &[], &it.text);
+        w.close("a:r");
+        w.close("a:p");
+        w.close("dgm:t");
+        w.close("dgm:pt");
+        for (id, ty) in [(&par, "parTrans"), (&sib, "sibTrans")] {
+            w.open("dgm:pt", &[("modelId", id), ("type", ty), ("cxnId", &cxn)]);
+            w.empty("dgm:prSet", &[]);
+            w.empty("dgm:spPr", &[]);
+            empty_t(&mut w);
+            w.close("dgm:pt");
+        }
+    }
+    w.close("dgm:ptLst");
+    w.open("dgm:cxnLst", &[]);
+    let parents = spec.parents();
+    let mut order = vec![0usize; spec.items.len() + 1];
+    for (i, p) in parents.iter().enumerate() {
+        let (node, cxn, par, sib) = item_ids(i);
+        let src = p.map_or_else(|| doc.clone(), |p| item_ids(p).0);
+        let slot = p.map_or(0, |p| p + 1);
+        let ord = order.get(slot).copied().unwrap_or(0);
+        if let Some(o) = order.get_mut(slot) {
+            *o += 1;
+        }
+        w.empty(
+            "dgm:cxn",
+            &[
+                ("modelId", &cxn),
+                ("srcId", &src),
+                ("destId", &node),
+                ("srcOrd", &ord.to_string()),
+                ("destOrd", "0"),
+                ("parTransId", &par),
+                ("sibTransId", &sib),
+            ],
+        );
+    }
+    w.close("dgm:cxnLst");
+    w.empty("dgm:bg", &[]);
+    w.empty("dgm:whole", &[]);
+    w.open("dgm:extLst", &[]);
+    w.open("a:ext", &[("uri", DRAWING_EXT_URI)]);
+    w.empty(
+        "dsp:dataModelExt",
+        &[("xmlns:dsp", NS_DSP), ("relId", drawing_rel), ("minVer", "http://schemas.openxmlformats.org/drawingml/2006/diagram")],
+    );
+    w.close("a:ext");
+    w.close("dgm:extLst");
+    w.close("dgm:dataModel");
+    w.s
+}
+
+/// A layout node: `alg` with its parameters, a shape (`None`: no geometry), what text it shows
+/// (`presOf` attributes), then `body`.
+fn layout_node(
+    w: &mut W,
+    name: &str,
+    style: Option<&str>,
+    alg: &str,
+    params: &[(&str, &str)],
+    shape: Option<&str>,
+    pres_of: &[(&str, &str)],
+    body: impl FnOnce(&mut W),
+) {
+    let mut attrs = vec![("name", name)];
+    if let Some(s) = style {
+        attrs.push(("styleLbl", s));
+    }
+    w.open("dgm:layoutNode", &attrs);
+    if params.is_empty() {
+        w.empty("dgm:alg", &[("type", alg)]);
+    } else {
+        w.open("dgm:alg", &[("type", alg)]);
+        for (t, v) in params {
+            w.empty("dgm:param", &[("type", t), ("val", v)]);
+        }
+        w.close("dgm:alg");
+    }
+    let mut sa = vec![("r:blip", "")];
+    if let Some(t) = shape {
+        sa.insert(0, ("type", t));
+    }
+    w.open("dgm:shape", &sa);
+    w.empty("dgm:adjLst", &[]);
+    w.close("dgm:shape");
+    w.empty("dgm:presOf", pres_of);
+    w.empty("dgm:constrLst", &[]);
+    w.empty("dgm:ruleLst", &[]);
+    body(w);
+    w.close("dgm:layoutNode");
+}
+
+/// The text node of an item: its own text and the items under it as bullets.
+const ITEM_TEXT: &[(&str, &str)] = &[("axis", "desc;self"), ("ptType", "node;node"), ("st", "1;1"), ("cnt", "0;1")];
+
+/// A layout definition (`dgm:layoutDef`) of our own for `l`, named by its layout identifier.
+pub fn layout_xml(l: SmartArtLayout) -> String {
+    let (id, cat) = layout_id(l);
+    let mut w = W::new();
+    w.open("dgm:layoutDef", &[("xmlns:dgm", NS_DGM), ("xmlns:a", NS_A), ("xmlns:r", NS_R), ("uniqueId", id)]);
+    w.empty("dgm:title", &[("val", l.label())]);
+    w.empty("dgm:desc", &[("val", l.description())]);
+    w.open("dgm:catLst", &[]);
+    w.empty("dgm:cat", &[("type", cat), ("pri", "1000")]);
+    w.close("dgm:catLst");
+    let (alg, params): (&str, &[(&str, &str)]) = match l {
+        SmartArtLayout::BasicList | SmartArtLayout::Matrix => ("snake", &[("grDir", "tL"), ("flowDir", "row"), ("contDir", "sameDir")]),
+        SmartArtLayout::Process => ("lin", &[("linDir", "fromL"), ("nodeVertAlign", "mid")]),
+        SmartArtLayout::Cycle | SmartArtLayout::Venn => ("cycle", &[("stAng", "0"), ("spanAng", "360")]),
+        SmartArtLayout::Radial => ("cycle", &[("stAng", "0"), ("spanAng", "360"), ("ctrShpMap", "fNode")]),
+        SmartArtLayout::Hierarchy => ("hierChild", &[("linDir", "fromL"), ("chAlign", "t")]),
+        SmartArtLayout::Pyramid => ("pyra", &[("linDir", "fromT")]),
+    };
+    let shape = match l {
+        SmartArtLayout::BasicList => "rect",
+        SmartArtLayout::Process | SmartArtLayout::Hierarchy | SmartArtLayout::Matrix => "roundRect",
+        SmartArtLayout::Cycle | SmartArtLayout::Radial | SmartArtLayout::Venn => "ellipse",
+        SmartArtLayout::Pyramid => "trapezoid",
+    };
+    layout_node(&mut w, "diagram", None, alg, params, None, &[], |w| match l {
+        SmartArtLayout::Hierarchy => {
+            w.open("dgm:forEach", &[("name", "branches"), ("axis", "ch"), ("ptType", "node")]);
+            layout_node(w, "branch", None, "hierRoot", &[], None, &[], |w| {
+                layout_node(w, "item", Some("node1"), "tx", &[], Some(shape), &[("axis", "self")], |_| {});
+                layout_node(w, "below", None, "hierChild", &[("chAlign", "t")], None, &[], |w| {
+                    w.open("dgm:forEach", &[("name", "joins"), ("axis", "ch"), ("ptType", "parTrans")]);
+                    layout_node(
+                        w,
+                        "join",
+                        Some("connector"),
+                        "conn",
+                        &[("dim", "1D"), ("connRout", "bend"), ("begPts", "bCtr"), ("endPts", "tCtr")],
+                        Some("conn"),
+                        &[("axis", "self")],
+                        |_| {},
+                    );
+                    w.close("dgm:forEach");
+                    w.empty("dgm:forEach", &[("name", "deeper"), ("ref", "branches")]);
+                });
+            });
+            w.close("dgm:forEach");
+        }
+        SmartArtLayout::Radial => {
+            w.open("dgm:forEach", &[("name", "middle"), ("axis", "ch"), ("ptType", "node"), ("cnt", "1")]);
+            layout_node(w, "centre", Some("node1"), "tx", &[], Some(shape), &[("axis", "self")], |w| {
+                w.open("dgm:forEach", &[("name", "around"), ("axis", "ch"), ("ptType", "node")]);
+                layout_node(w, "spoke", Some("node1"), "tx", &[], Some(shape), ITEM_TEXT, |_| {});
+                w.close("dgm:forEach");
+            });
+            w.close("dgm:forEach");
+        }
+        _ => {
+            w.open("dgm:forEach", &[("name", "items"), ("axis", "ch"), ("ptType", "node")]);
+            let style = if l == SmartArtLayout::Venn { "venn" } else { "node1" };
+            layout_node(w, "item", Some(style), "tx", &[], Some(shape), ITEM_TEXT, |_| {});
+            if matches!(l, SmartArtLayout::Process | SmartArtLayout::Cycle) {
+                w.open("dgm:forEach", &[("name", "arrows"), ("axis", "followSib"), ("ptType", "sibTrans"), ("cnt", "1")]);
+                layout_node(w, "arrow", Some("connector"), "conn", &[("dim", "2D")], Some("rightArrow"), &[("axis", "self")], |_| {});
+                w.close("dgm:forEach");
+            }
+            w.close("dgm:forEach");
+        }
+    });
+    w.close("dgm:layoutDef");
+    w.s
+}
+
+/// The style labels our layouts name.
+const STYLE_LABELS: [&str; 3] = ["node1", "connector", "venn"];
+
+fn scheme_list(w: &mut W, tag: &str, meth: &str, vals: &[String]) {
+    w.open(tag, &[("meth", meth)]);
+    for v in vals {
+        w.empty("a:schemeClr", &[("val", v)]);
+    }
+    w.close(tag);
+}
+
+/// A colour definition (`dgm:colorsDef`) of our own for `c`.
+pub fn colors_xml(c: SmartArtColors) -> String {
+    let (id, cat) = colors_id(c);
+    let accents: Vec<String> = match c {
+        SmartArtColors::Colorful => (1..=6).map(|n| format!("accent{n}")).collect(),
+        _ => vec![format!("accent{}", c.accent(0))],
+    };
+    let meth = if c == SmartArtColors::Colorful { "cycle" } else { "repeat" };
+    let mut w = W::new();
+    w.open("dgm:colorsDef", &[("xmlns:dgm", NS_DGM), ("xmlns:a", NS_A), ("uniqueId", &id)]);
+    w.empty("dgm:title", &[("val", c.label())]);
+    w.empty("dgm:desc", &[("val", "")]);
+    w.open("dgm:catLst", &[]);
+    w.empty("dgm:cat", &[("type", &cat), ("pri", "1000")]);
+    w.close("dgm:catLst");
+    for lbl in STYLE_LABELS {
+        w.open("dgm:styleLbl", &[("name", lbl)]);
+        scheme_list(&mut w, "dgm:fillClrLst", meth, &accents);
+        scheme_list(&mut w, "dgm:linClrLst", "repeat", &["lt1".to_string()]);
+        w.empty("dgm:effectClrLst", &[]);
+        w.empty("dgm:txLinClrLst", &[]);
+        scheme_list(&mut w, "dgm:txFillClrLst", "repeat", &[if lbl == "venn" { "tx1" } else { "lt1" }.to_string()]);
+        w.empty("dgm:txEffectClrLst", &[]);
+        w.close("dgm:styleLbl");
+    }
+    w.close("dgm:colorsDef");
+    w.s
+}
+
+/// The quick style (`dgm:styleDef`) of our own: flat shapes in the theme's plain line and fill.
+pub fn quick_style_xml() -> String {
+    let mut w = W::new();
+    w.open("dgm:styleDef", &[("xmlns:dgm", NS_DGM), ("xmlns:a", NS_A), ("uniqueId", QUICK_STYLE_ID)]);
+    w.empty("dgm:title", &[("val", "Flat")]);
+    w.empty("dgm:desc", &[("val", "")]);
+    w.open("dgm:catLst", &[]);
+    w.empty("dgm:cat", &[("type", "simple"), ("pri", "1000")]);
+    w.close("dgm:catLst");
+    let scene = |w: &mut W| {
+        w.open("dgm:scene3d", &[]);
+        w.empty("a:camera", &[("prst", "orthographicFront")]);
+        w.empty("a:lightRig", &[("rig", "threePt"), ("dir", "t")]);
+        w.close("dgm:scene3d");
+    };
+    scene(&mut w);
+    for lbl in STYLE_LABELS {
+        w.open("dgm:styleLbl", &[("name", lbl)]);
+        scene(&mut w);
+        w.empty("dgm:sp3d", &[]);
+        w.empty("dgm:txPr", &[]);
+        w.open("dgm:style", &[]);
+        for (name, idx) in [("a:lnRef", "2"), ("a:fillRef", "1"), ("a:effectRef", "0")] {
+            w.open(name, &[("idx", idx)]);
+            w.empty("a:scrgbClr", &[("r", "0"), ("g", "0"), ("b", "0")]);
+            w.close(name);
+        }
+        w.open("a:fontRef", &[("idx", "minor")]);
+        w.empty("a:schemeClr", &[("val", if lbl == "venn" { "tx1" } else { "lt1" })]);
+        w.close("a:fontRef");
+        w.close("dgm:style");
+        w.close("dgm:styleLbl");
+    }
+    w.close("dgm:styleDef");
+    w.s
+}
+
+// ---- reading back ----
+
+/// The graphic a data part holds, when the part is exactly what [`data_xml`] writes for it (so
+/// editing and saving it loses nothing). `None` for any other diagram.
+pub(crate) fn spec_of(data: &El) -> Option<SmartArtSpec> {
+    let pts = data.child("dgm:ptLst")?;
+    let doc = pts.children("dgm:pt").find(|p| p.attr("type") == Some("doc"))?;
+    let pr = doc.child("dgm:prSet")?;
+    let lo = pr.attr("loTypeId")?;
+    let layout = SmartArtLayout::ALL.into_iter().find(|l| layout_id(*l).0 == lo)?;
+    let cs = pr.attr("csTypeId")?;
+    let colors = SmartArtColors::ALL.into_iter().find(|c| colors_id(*c).0 == cs)?;
+    let rel = data.find("dsp:dataModelExt")?.attr("relId")?.to_string();
+    // Items are node points (no type) in order; more than the model holds can't be ours.
+    let nodes: Vec<&El> = pts.children("dgm:pt").filter(|p| p.attr("type").is_none()).take(MAX_ITEMS + 1).collect();
+    if nodes.len() > MAX_ITEMS {
+        return None;
+    }
+    let doc_id = doc.attr("modelId")?;
+    let index: Vec<&str> = nodes.iter().filter_map(|p| p.attr("modelId")).collect();
+    let mut levels: Vec<Option<u8>> = vec![None; nodes.len()];
+    for c in data.child("dgm:cxnLst")?.children("dgm:cxn").take(MAX_ITEMS + 1) {
+        let dest = index.iter().position(|id| Some(*id) == c.attr("destId"))?;
+        let src = c.attr("srcId")?;
+        let level = if src == doc_id {
+            0
+        } else {
+            let p = index.iter().position(|id| *id == src)?;
+            levels.get(p).copied().flatten()?.checked_add(1)?
+        };
+        *levels.get_mut(dest)? = Some(level);
+    }
+    let items = nodes
+        .iter()
+        .zip(&levels)
+        .map(|(p, l)| {
+            let text: String = p.child("dgm:t")?.child("a:p")?.children("a:r").filter_map(|r| r.child("a:t")).map(|t| t.text()).collect();
+            Some(SmartArtItem { text, level: (*l)? })
+        })
+        .collect::<Option<Vec<_>>>()?;
+    let spec = SmartArtSpec { layout, items, colors }.sanitized();
+    // Editable only when nothing would be lost: writing the model again gives the same part.
+    let again = xml::parse(data_xml(&spec, &rel).as_bytes()).ok()?;
+    same(data, &again, 0).then_some(spec)
+}
+
+/// Whether two elements are the same markup: names, attributes (in any order), child elements in
+/// order and text (whitespace-only text between elements ignored).
+fn same(a: &El, b: &El, depth: usize) -> bool {
+    if depth > MAX_DEPTH || a.name != b.name || a.attrs.len() != b.attrs.len() {
+        return false;
+    }
+    if !a.attrs.iter().all(|(k, v)| b.attr(k) == Some(v.as_str())) {
+        return false;
+    }
+    let text = |e: &El| -> String {
+        e.kids
+            .iter()
+            .filter_map(|n| match n {
+                Node::Text(t) if !t.trim().is_empty() => Some(t.as_str()),
+                _ => None,
+            })
+            .collect()
+    };
+    if text(a) != text(b) {
+        return false;
+    }
+    let (mut x, mut y) = (a.els(), b.els());
+    loop {
+        match (x.next(), y.next()) {
+            (None, None) => return true,
+            (Some(p), Some(q)) if same(p, q, depth + 1) => {}
+            _ => return false,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use wordcraft_doc::THEME_COLORS;
+
+    fn parse(s: &str) -> El {
+        xml::parse(s.as_bytes()).unwrap()
+    }
+
+    fn names(e: &El) -> Vec<&str> {
+        e.els().map(|c| c.name.as_str()).collect()
+    }
+
+    #[test]
+    fn every_layout_reads_back_and_draws_inside_its_frame() {
+        for layout in SmartArtLayout::ALL {
+            for colors in [SmartArtColors::Accent3, SmartArtColors::Colorful] {
+                let mut spec = SmartArtSpec::sample(layout);
+                spec.colors = colors;
+                spec.items.push(SmartArtItem::new("Under <last> & more", 1));
+                let spec = spec.sanitized();
+                assert_eq!(spec_of(&parse(&data_xml(&spec, "rId9"))).as_ref(), Some(&spec), "{layout:?}");
+                let items = smart_art_items(&spec, &THEME_COLORS, 400.0, 250.0);
+                assert!(items.iter().any(|i| matches!(i, GraphicItem::Text { .. })), "{layout:?} has text");
+                for it in &items {
+                    if let GraphicItem::Shape { rect, .. } = it {
+                        assert!(
+                            rect[0] >= -0.5 && rect[1] >= -0.5 && rect[0] + rect[2] <= 400.5 && rect[1] + rect[3] <= 250.5,
+                            "{layout:?}: {rect:?}"
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn a_diagram_with_more_than_the_model_stays_read_only() {
+        let spec = SmartArtSpec::sample(SmartArtLayout::Process);
+        let x = data_xml(&spec, "rId4");
+        assert_eq!(spec_of(&parse(&x.replace("<dgm:bg/>", "<dgm:bg><a:noFill/></dgm:bg>"))), None);
+        assert_eq!(spec_of(&parse(&x.replace("layout/process1", "layout/process9"))), None);
+        // A run split in two (as another program might save it) isn't ours either.
+        let split = x.replace(
+            "<a:r><a:rPr lang=\"en-US\"/><a:t>Plan</a:t></a:r>",
+            "<a:r><a:rPr lang=\"en-US\"/><a:t>Pl</a:t></a:r><a:r><a:rPr lang=\"en-US\"/><a:t>an</a:t></a:r>",
+        );
+        assert_ne!(split, x);
+        assert_eq!(spec_of(&parse(&split)), None);
+    }
+
+    #[test]
+    fn parts_come_in_schema_order() {
+        let spec = SmartArtSpec::sample(SmartArtLayout::Hierarchy);
+        let data = parse(&data_xml(&spec, "rId1"));
+        assert_eq!(names(&data), ["dgm:ptLst", "dgm:cxnLst", "dgm:bg", "dgm:whole", "dgm:extLst"]);
+        let pt = data.child("dgm:ptLst").unwrap().els().nth(1).unwrap();
+        assert_eq!(names(pt), ["dgm:prSet", "dgm:spPr", "dgm:t"]);
+        // Each item's connection names its parent: Design (item 1) under Lead (item 0).
+        let cx = data.child("dgm:cxnLst").unwrap().els().nth(1).unwrap();
+        assert_eq!(cx.attr("srcId"), Some(model_id(1).as_str()));
+        let drawing = parse(&drawing_xml(&spec, 300.0, 200.0));
+        let tree = drawing.child("dsp:spTree").unwrap();
+        assert_eq!(names(tree).first(), Some(&"dsp:nvGrpSpPr"));
+        let sp = tree.children("dsp:sp").last().unwrap();
+        assert_eq!(names(sp), ["dsp:nvSpPr", "dsp:spPr", "dsp:style", "dsp:txBody", "dsp:txXfrm"]);
+        assert_eq!(names(sp.child("dsp:spPr").unwrap()), ["a:xfrm", "a:prstGeom", "a:solidFill", "a:ln"]);
+        for part in [layout_xml(SmartArtLayout::Radial), colors_xml(SmartArtColors::Colorful), quick_style_xml()] {
+            let el = parse(&part);
+            assert_eq!(&names(&el)[..3], ["dgm:title", "dgm:desc", "dgm:catLst"]);
+        }
+    }
+
+    #[test]
+    fn hostile_sizes_and_many_items_stay_finite() {
+        let spec =
+            SmartArtSpec { items: (0..MAX_ITEMS).map(|i| SmartArtItem::new("word ".repeat(50), (i % 9) as u8)).collect(), ..Default::default() }
+                .sanitized();
+        for layout in SmartArtLayout::ALL {
+            let spec = SmartArtSpec { layout, ..spec.clone() };
+            for (w, h) in [(f32::NAN, 10.0), (0.0, 0.0), (1.0e30, 5.0), (300.0, 200.0)] {
+                for it in smart_art_items(&spec, &THEME_COLORS, w, h) {
+                    if let GraphicItem::Shape { rect, .. } | GraphicItem::Text { rect, .. } = it {
+                        assert!(rect.iter().all(|v| v.is_finite()), "{layout:?} {w} {h}");
+                    }
+                }
+            }
+        }
+    }
+}
diff --git a/crates/docx/src/wordml2003.rs b/crates/docx/src/wordml2003.rs
new file mode 100644
index 0000000000..31de867697
--- /dev/null
+++ b/crates/docx/src/wordml2003.rs
@@ -0,0 +1,576 @@
+//! Word 2003 XML Document (WordprocessingML 2003, root `w:wordDocument`, from the public Office
+//! 2003 XML Reference Schemas). Import only.
+//!
+//! ECMA-376 kept most of the 2003 vocabulary (`w:p`, `w:r`, `w:pPr`, `w:rPr`, `w:tbl`,
+//! `w:sectPr`, `w:styles`…), so the file is opened by rewriting it as the package it corresponds
+//! to and reading that with the DOCX reader: one reader, one set of property rules. The rewrite
+//! renames what changed (hyphenated names, `w:hlink`, `w:listPr`, `w:nfc`, `w:vmerge`…), moves
+//! what 2003 keeps inline into parts (lists into numbering, headers and footers, footnotes,
+//! endnotes, comments, `w:binData` pictures into media) and turns `aml:annotation` bookmarks,
+//! comments and tracked insertions/deletions into their ECMA-376 elements. Bounded: the parser
+//! caps depth and element count, pictures are capped in number and size.
+
+use std::collections::{BTreeMap, HashMap};
+
+use base64::Engine as _;
+use wordcraft_doc::Document;
+
+use crate::DocxError;
+use crate::flat::W2003_NS;
+use crate::package::{MAX_PART, MAX_TOTAL, Package, rt};
+use crate::write::PartRels;
+use crate::xml::{self, El, MAX_DEPTH, NAMESPACES, Node, W};
+
+/// Auxiliary hints (`wx:`): display hints Word writes alongside the real markup.
+const AUX_NS: &str = "http://schemas.microsoft.com/office/word/2003/auxHint";
+/// Annotation markup (`aml:`): bookmarks, comments, tracked changes.
+const AML_NS: &str = "http://schemas.microsoft.com/aml/2001/core";
+
+/// Most pictures (`w:binData`) taken from one file.
+const MAX_MEDIA: usize = 4096;
+/// Most header, footer, footnote, endnote and comment stories.
+const MAX_STORIES: usize = 50_000;
+
+/// Read a Word 2003 XML Document.
+pub fn read(bytes: &[u8]) -> Result<Document, DocxError> {
+    crate::read::read_opened(&convert(bytes)?)
+}
+
+/// Parts the converted package gets relationships for.
+const DOC: usize = 0;
+const FOOTNOTES: usize = 1;
+const ENDNOTES: usize = 2;
+const COMMENTS: usize = 3;
+
+struct Conv {
+    /// `w:binData` name (`wordml://…`) → media target relative to `word/`.
+    media: HashMap<String, String>,
+    files: BTreeMap<String, Vec<u8>>,
+    /// Relationships per part: document, footnotes, endnotes, comments, then one per header or
+    /// footer (index in `stories` + 4).
+    rels: Vec<PartRels>,
+    footnotes: Vec<Node>,
+    endnotes: Vec<Node>,
+    comments: Vec<Node>,
+    /// Header and footer parts: (part name under `word/`, root element).
+    stories: Vec<(String, El)>,
+    next_note: i64,
+    story_count: usize,
+}
+
+/// Rewrite a Word 2003 XML Document as a WordprocessingML package.
+pub(crate) fn convert(bytes: &[u8]) -> Result<Package, DocxError> {
+    let root = xml::parse_ns(bytes, &[("w", W2003_NS), ("wx", AUX_NS), ("aml", AML_NS)])?;
+    if root.name != "w:wordDocument" {
+        return Err(DocxError::NotWord(format!("root element is {}", root.name)));
+    }
+    let mut c = Conv {
+        media: HashMap::new(),
+        files: BTreeMap::new(),
+        rels: (0..4).map(|_| PartRels::default()).collect(),
+        footnotes: Vec::new(),
+        endnotes: Vec::new(),
+        comments: Vec::new(),
+        stories: Vec::new(),
+        next_note: 1,
+        story_count: 0,
+    };
+    let mut total = 0u64;
+    c.collect_media(&root, 0, &mut total)?;
+
+    // Body: `wx:sect` / `wx:sub-section` wrappers unwrapped; the last section's properties last.
+    let mut body = El { name: "w:body".into(), ..El::default() };
+    if let Some(b) = root.child("w:body") {
+        body.kids = c.kids(b, DOC, 1);
+    }
+    let last_sect = body.kids.iter().rposition(|n| matches!(n, Node::El(e) if e.name == "w:sectPr"));
+    if let Some(i) = last_sect {
+        let s = body.kids.remove(i);
+        body.kids.retain(|n| !matches!(n, Node::El(e) if e.name == "w:sectPr"));
+        body.kids.push(s);
+    }
+    let mut document = El { name: "w:document".into(), attrs: xml::body_ns(), kids: Vec::new() };
+    document.kids.push(Node::El(body));
+
+    let mut overrides: Vec<(String, &str)> = Vec::new();
+    let wml = |s: &str| format!("application/vnd.openxmlformats-officedocument.wordprocessingml.{s}+xml");
+    let styles = c.styles(&root);
+    c.put("word/styles.xml", &styles);
+    c.rels[DOC].add(rt::STYLES, "styles.xml", false);
+    overrides.push(("/word/styles.xml".into(), "styles"));
+    if let Some(n) = root.child("w:lists").map(|l| c.numbering(l)) {
+        c.put("word/numbering.xml", &n);
+        c.rels[DOC].add(rt::NUMBERING, "numbering.xml", false);
+        overrides.push(("/word/numbering.xml".into(), "numbering"));
+    }
+    for (part, root_name, kids, rel, ct) in [
+        (FOOTNOTES, "w:footnotes", std::mem::take(&mut c.footnotes), rt::FOOTNOTES, "footnotes"),
+        (ENDNOTES, "w:endnotes", std::mem::take(&mut c.endnotes), rt::ENDNOTES, "endnotes"),
+        (COMMENTS, "w:comments", std::mem::take(&mut c.comments), rt::COMMENTS, "comments"),
+    ] {
+        if kids.is_empty() {
+            continue;
+        }
+        let file = format!("{ct}.xml");
+        c.put(&format!("word/{file}"), &El { name: root_name.into(), attrs: xml::body_ns(), kids });
+        c.put_rels(&file, part);
+        c.rels[DOC].add(rel, &file, false);
+        overrides.push((format!("/word/{file}"), ct));
+    }
+    for (i, (file, story)) in std::mem::take(&mut c.stories).into_iter().enumerate() {
+        c.put(&format!("word/{file}"), &story);
+        c.put_rels(&file, i + 4);
+        overrides.push((format!("/word/{file}"), if story.name == "w:ftr" { "footer" } else { "header" }));
+    }
+    c.put("word/document.xml", &document);
+    c.put_rels("document.xml", DOC);
+
+    let mut root_rels = PartRels::default();
+    root_rels.add(rt::OFFICE_DOC, "word/document.xml", false);
+    if let Some(props) = root.child("o:DocumentProperties") {
+        c.files.insert("docProps/core.xml".into(), core_xml(props));
+        root_rels.add(rt::CORE, "docProps/core.xml", false);
+    }
+    c.files.insert("_rels/.rels".into(), root_rels.xml());
+
+    let mut w = W::new();
+    w.open("Types", &[("xmlns", "http://schemas.openxmlformats.org/package/2006/content-types")]);
+    w.empty("Default", &[("Extension", "rels"), ("ContentType", "application/vnd.openxmlformats-package.relationships+xml")]);
+    w.empty("Default", &[("Extension", "xml"), ("ContentType", "application/xml")]);
+    let mut exts: Vec<&str> = c.media.values().filter_map(|t| t.rsplit_once('.').map(|(_, e)| e)).collect();
+    exts.sort_unstable();
+    exts.dedup();
+    for ext in exts {
+        w.empty("Default", &[("Extension", ext), ("ContentType", media_type(ext))]);
+    }
+    w.empty("Override", &[("PartName", "/word/document.xml"), ("ContentType", &wml("document.main"))]);
+    for (part, kind) in &overrides {
+        w.empty("Override", &[("PartName", part), ("ContentType", &wml(kind))]);
+    }
+    if c.files.contains_key("docProps/core.xml") {
+        w.empty("Override", &[("PartName", "/docProps/core.xml"), ("ContentType", "application/vnd.openxmlformats-package.core-properties+xml")]);
+    }
+    w.close("Types");
+    c.files.insert("[Content_Types].xml".into(), w.into_bytes());
+    Ok(Package::from_parts(c.files))
+}
+
+impl Conv {
+    /// Store an element as a part.
+    fn put(&mut self, path: &str, root: &El) {
+        let mut s = String::from("<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>\n");
+        s.push_str(&root.to_xml());
+        self.files.insert(path.into(), s.into_bytes());
+    }
+
+    /// Store the relationships of `word/{file}` (if it has any).
+    fn put_rels(&mut self, file: &str, part: usize) {
+        if let Some(r) = self.rels.get(part).filter(|r| !r.is_empty()) {
+            let x = r.xml();
+            self.files.insert(format!("word/_rels/{file}.rels"), x);
+        }
+    }
+
+    /// Every `w:binData` in the file, decoded into a media part.
+    fn collect_media(&mut self, e: &El, depth: usize, total: &mut u64) -> Result<(), DocxError> {
+        if depth > MAX_DEPTH {
+            return Ok(());
+        }
+        for k in e.els() {
+            if k.name == "w:binData" {
+                let Some(name) = k.attr("w:name").filter(|n| !self.media.contains_key(*n)) else { continue };
+                if self.media.len() >= MAX_MEDIA {
+                    continue;
+                }
+                let text = k.text();
+                let b64: String = text.chars().filter(|c| !c.is_ascii_whitespace()).collect();
+                if (b64.len() / 4 * 3) as u64 > MAX_PART {
+                    return Err(DocxError::Limit(format!("picture {name} is larger than the size limit")));
+                }
+                let Ok(bytes) = base64::engine::general_purpose::STANDARD_NO_PAD.decode(b64.trim_end_matches('=')) else {
+                    log::warn!("wordml2003: skipping picture {name}: invalid base64");
+                    continue;
+                };
+                *total = total.saturating_add(bytes.len() as u64);
+                if *total > MAX_TOTAL {
+                    return Err(DocxError::Limit("pictures larger than the size limit".into()));
+                }
+                let ext = picture_ext(&bytes, name);
+                let target = format!("media/image{}.{ext}", self.media.len() + 1);
+                self.files.insert(format!("word/{target}"), bytes);
+                self.media.insert(name.to_string(), target);
+            } else {
+                self.collect_media(k, depth + 1, total)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// The converted children of `e`.
+    fn kids(&mut self, e: &El, part: usize, depth: usize) -> Vec<Node> {
+        let mut out = Vec::with_capacity(e.kids.len());
+        for n in &e.kids {
+            match n {
+                Node::Text(t) => out.push(Node::Text(t.clone())),
+                Node::El(k) => out.extend(self.node(k, part, depth + 1)),
+            }
+        }
+        out
+    }
+
+    /// `e` converted: nothing (dropped), its children (unwrapped) or one element.
+    fn node(&mut self, e: &El, part: usize, depth: usize) -> Vec<Node> {
+        if depth > MAX_DEPTH {
+            return Vec::new();
+        }
+        match e.name.as_str() {
+            "wx:sect" | "wx:sub-section" | "wx:pBdrGroup" => return self.kids(e, part, depth),
+            "w:binData" | "w:fonts" | "w:docPr" | "w:lists" | "w:styles" | "w:latentStyles" | "w:versionOfBuiltInStyleNames" => return Vec::new(),
+            "w:hlink" => return vec![Node::El(self.hyperlink(e, part, depth))],
+            "w:listPr" => return vec![Node::El(list_pr(e))],
+            "w:footnote" | "w:endnote" => return self.note(e, depth).into_iter().map(Node::El).collect(),
+            "aml:annotation" => return self.annotation(e, part, depth),
+            "w:sectPr" => return vec![Node::El(self.section(e, part, depth))],
+            "w:nfc" => return vec![Node::El(num_fmt(e))],
+            _ => {}
+        }
+        if !keep(&e.name) {
+            return Vec::new();
+        }
+        let mut el = El { name: rename(&e.name), attrs: attrs(e), kids: self.kids(e, part, depth) };
+        if el.name == "v:imagedata"
+            && let Some(target) = e.attr("src").and_then(|s| self.media.get(s)).cloned()
+            && let Some(r) = self.rels.get_mut(part)
+        {
+            let id = r.add(rt::IMAGE, &target, false);
+            el.attrs.retain(|(k, _)| k != "r:id");
+            el.attrs.push(("r:id".into(), id));
+        }
+        if el.name == "w:style" {
+            for (k, v) in &mut el.attrs {
+                if k == "w:default" && v == "on" {
+                    *v = "1".into();
+                }
+            }
+        }
+        vec![Node::El(el)]
+    }
+
+    /// `w:hlink` → `w:hyperlink` (an external relationship for `w:dest`).
+    fn hyperlink(&mut self, e: &El, part: usize, depth: usize) -> El {
+        let mut attrs = Vec::new();
+        if let Some(dest) = e.attr("w:dest").filter(|d| !d.is_empty())
+            && let Some(r) = self.rels.get_mut(part)
+        {
+            attrs.push(("r:id".into(), r.add(rt::HYPERLINK, dest, true)));
+        }
+        for (from, to) in [("w:bookmark", "w:anchor"), ("w:screenTip", "w:tooltip"), ("w:target", "w:tgtFrame")] {
+            if let Some(v) = e.attr(from) {
+                attrs.push((to.into(), v.to_string()));
+            }
+        }
+        El { name: "w:hyperlink".into(), attrs, kids: self.kids(e, part, depth) }
+    }
+
+    /// A footnote or endnote written inline in its run → a reference, the note in its part.
+    fn note(&mut self, e: &El, depth: usize) -> Option<El> {
+        // Separator definitions (`w:type`) live in document settings, not in the text.
+        if e.attr("w:type").is_some() || self.story_count >= MAX_STORIES {
+            return None;
+        }
+        self.story_count += 1;
+        let foot = e.name == "w:footnote";
+        let id = self.next_note.to_string();
+        self.next_note = self.next_note.saturating_add(1);
+        let part = if foot { FOOTNOTES } else { ENDNOTES };
+        let kids = self.kids(e, part, depth);
+        let note = El { name: e.name.clone(), attrs: vec![("w:id".into(), id.clone())], kids };
+        if foot {
+            self.footnotes.push(Node::El(note));
+        } else {
+            self.endnotes.push(Node::El(note));
+        }
+        let name = if foot { "w:footnoteReference" } else { "w:endnoteReference" };
+        Some(El { name: name.into(), attrs: vec![("w:id".into(), id)], kids: Vec::new() })
+    }
+
+    /// `aml:annotation`: bookmarks, comments and tracked insertions/deletions.
+    fn annotation(&mut self, e: &El, part: usize, depth: usize) -> Vec<Node> {
+        let id = e.attr("aml:id").filter(|v| v.parse::<i64>().is_ok()).unwrap_or("0").to_string();
+        let el = |name: &str, attrs: Vec<(String, String)>| vec![Node::El(El { name: name.into(), attrs, kids: Vec::new() })];
+        let author_date = |e: &El| {
+            let mut a = vec![("w:id".to_string(), id.clone())];
+            if let Some(v) = e.attr("aml:author") {
+                a.push(("w:author".into(), v.to_string()));
+            }
+            if let Some(v) = e.attr("aml:createdate") {
+                a.push(("w:date".into(), v.to_string()));
+            }
+            a
+        };
+        let content = |c: &mut Conv, part: usize| e.child("aml:content").map(|k| c.kids(k, part, depth + 1)).unwrap_or_default();
+        match e.attr("w:type").unwrap_or("") {
+            "Word.Bookmark.Start" => {
+                el("w:bookmarkStart", vec![("w:id".into(), id.clone()), ("w:name".into(), e.attr("w:name").unwrap_or("").to_string())])
+            }
+            "Word.Bookmark.End" => el("w:bookmarkEnd", vec![("w:id".into(), id)]),
+            "Word.Comment.Start" => el("w:commentRangeStart", vec![("w:id".into(), id)]),
+            "Word.Comment.End" => el("w:commentRangeEnd", vec![("w:id".into(), id)]),
+            "Word.Comment" => {
+                if self.story_count >= MAX_STORIES {
+                    return Vec::new();
+                }
+                self.story_count += 1;
+                let mut attrs = author_date(e);
+                if let Some(v) = e.attr("w:initials") {
+                    attrs.push(("w:initials".into(), v.to_string()));
+                }
+                let kids = content(self, COMMENTS);
+                self.comments.push(Node::El(El { name: "w:comment".into(), attrs, kids }));
+                el("w:commentReference", vec![("w:id".into(), id)])
+            }
+            t @ ("Word.Insertion" | "Word.Deletion") => {
+                let name = if t == "Word.Insertion" { "w:ins" } else { "w:del" };
+                vec![Node::El(El { name: name.into(), attrs: author_date(e), kids: content(self, part) })]
+            }
+            _ => Vec::new(),
+        }
+    }
+
+    /// `w:sectPr`: inline `w:hdr` / `w:ftr` become header and footer parts.
+    fn section(&mut self, e: &El, part: usize, depth: usize) -> El {
+        let mut refs = Vec::new();
+        let mut rest = Vec::new();
+        for n in &e.kids {
+            let Node::El(k) = n else { continue };
+            if (k.name == "w:hdr" || k.name == "w:ftr") && self.story_count < MAX_STORIES {
+                self.story_count += 1;
+                let footer = k.name == "w:ftr";
+                let kind = match k.attr("w:type") {
+                    Some("even") => "even",
+                    Some("first") => "first",
+                    _ => "default",
+                };
+                let idx = self.stories.len() + 4;
+                self.rels.push(PartRels::default());
+                let kids = self.kids(k, idx, depth + 1);
+                let file = format!("{}{}.xml", if footer { "footer" } else { "header" }, self.stories.len() + 1);
+                self.stories.push((file.clone(), El { name: k.name.clone(), attrs: xml::body_ns(), kids }));
+                let id = self.rels.get_mut(part).map(|r| r.add(if footer { rt::FOOTER } else { rt::HEADER }, &file, false)).unwrap_or_default();
+                let name = if footer { "w:footerReference" } else { "w:headerReference" };
+                refs.push(Node::El(El { name: name.into(), attrs: vec![("w:type".into(), kind.into()), ("r:id".into(), id)], kids: Vec::new() }));
+            } else if k.name != "w:hdr" && k.name != "w:ftr" {
+                rest.extend(self.node(k, part, depth + 1));
+            }
+        }
+        refs.extend(rest);
+        El { name: "w:sectPr".into(), attrs: attrs(e), kids: refs }
+    }
+
+    /// `w:styles` → `styles.xml`, with the document's default fonts (`w:fonts/w:defaultFonts`).
+    fn styles(&mut self, root: &El) -> El {
+        let mut kids = Vec::new();
+        if let Some(f) = root.child("w:fonts").and_then(|f| f.child("w:defaultFonts")) {
+            let fonts = El { name: "w:rFonts".into(), attrs: attrs(f), kids: Vec::new() };
+            let rpr = El { name: "w:rPr".into(), attrs: Vec::new(), kids: vec![Node::El(fonts)] };
+            let rpr_default = El { name: "w:rPrDefault".into(), attrs: Vec::new(), kids: vec![Node::El(rpr)] };
+            kids.push(Node::El(El { name: "w:docDefaults".into(), attrs: Vec::new(), kids: vec![Node::El(rpr_default)] }));
+        }
+        if let Some(s) = root.child("w:styles") {
+            for st in s.children("w:style") {
+                kids.extend(self.node(st, DOC, 2));
+            }
+        }
+        El { name: "w:styles".into(), attrs: xml::body_ns(), kids }
+    }
+
+    /// `w:lists` → `numbering.xml`: `w:listDef` → `w:abstractNum`, `w:list` → `w:num`.
+    fn numbering(&mut self, lists: &El) -> El {
+        let mut kids = Vec::new();
+        for def in lists.children("w:listDef") {
+            let Some(id) = def.attr("w:listDefId") else { continue };
+            let mut a = El { name: "w:abstractNum".into(), attrs: vec![("w:abstractNumId".into(), id.to_string())], kids: Vec::new() };
+            for k in def.els() {
+                let converted = match k.name.as_str() {
+                    "w:plt" => {
+                        let v = match k.attr("w:val").unwrap_or("") {
+                            "SingleLevel" => "singleLevel",
+                            "HybridMultilevel" => "hybridMultilevel",
+                            _ => "multilevel",
+                        };
+                        vec![Node::El(val_el("w:multiLevelType", v))]
+                    }
+                    "w:lsid" => vec![Node::El(val_el("w:nsid", k.attr("w:val").unwrap_or("")))],
+                    "w:listStyleLink" => vec![Node::El(val_el("w:numStyleLink", k.attr("w:val").unwrap_or("")))],
+                    _ => self.node(k, DOC, 2),
+                };
+                a.kids.extend(converted);
+            }
+            kids.push(Node::El(a));
+        }
+        for list in lists.children("w:list") {
+            let Some(id) = list.attr("w:ilfo") else { continue };
+            let Some(abs) = list.child_val("w:ilst") else { continue };
+            let mut n =
+                El { name: "w:num".into(), attrs: vec![("w:numId".into(), id.to_string())], kids: vec![Node::El(val_el("w:abstractNumId", abs))] };
+            for o in list.children("w:lvlOverride") {
+                n.kids.extend(self.node(o, DOC, 2));
+            }
+            kids.push(Node::El(n));
+        }
+        El { name: "w:numbering".into(), attrs: xml::body_ns(), kids }
+    }
+}
+
+/// `<name w:val="v"/>`.
+fn val_el(name: &str, v: &str) -> El {
+    El { name: name.into(), attrs: vec![("w:val".into(), v.into())], kids: Vec::new() }
+}
+
+/// `w:listPr` (`w:ilvl`, `w:ilfo`) → `w:numPr` (`w:ilvl`, `w:numId`).
+fn list_pr(e: &El) -> El {
+    let mut kids = Vec::new();
+    if let Some(v) = e.child_val("w:ilvl") {
+        kids.push(Node::El(val_el("w:ilvl", v)));
+    }
+    if let Some(v) = e.child_val("w:ilfo") {
+        kids.push(Node::El(val_el("w:numId", v)));
+    }
+    El { name: "w:numPr".into(), attrs: Vec::new(), kids }
+}
+
+/// `w:nfc` (a number format code) → `w:numFmt`.
+fn num_fmt(e: &El) -> El {
+    let f = match e.attr("w:val").and_then(|v| v.trim().parse::<u32>().ok()).unwrap_or(0) {
+        1 => "upperRoman",
+        2 => "lowerRoman",
+        3 => "upperLetter",
+        4 => "lowerLetter",
+        5 => "ordinal",
+        6 => "cardinalText",
+        7 => "ordinalText",
+        9 => "chicago",
+        14 | 19 => "decimalFullWidth",
+        15 => "decimalHalfWidth",
+        18 => "decimalEnclosedCircle",
+        22 => "decimalZero",
+        23 => "bullet",
+        24 => "ganada",
+        25 => "chosung",
+        26 => "decimalEnclosedFullstop",
+        27 => "decimalEnclosedParen",
+        255 => "none",
+        _ => "decimal",
+    };
+    val_el("w:numFmt", f)
+}
+
+/// Is an element or attribute with this name kept (a namespace the package knows, or none)?
+fn keep(name: &str) -> bool {
+    match name.split_once(':') {
+        None => true,
+        Some(("xml", _)) => true,
+        Some((p, _)) => NAMESPACES.iter().any(|(q, _)| *q == p),
+    }
+}
+
+/// A WordprocessingML 2003 name in its ECMA-376 spelling: `w:sz-cs` → `w:szCs`, `w:first-line`
+/// → `w:firstLine`, `w:fareast` → `w:eastAsia`, `w:vmerge` → `w:vMerge`.
+fn rename(name: &str) -> String {
+    let Some(local) = name.strip_prefix("w:") else { return name.to_string() };
+    match local {
+        "fareast" => return "w:eastAsia".into(),
+        "vmerge" => return "w:vMerge".into(),
+        "hmerge" => return "w:hMerge".into(),
+        _ => {}
+    }
+    let mut out = String::from("w:");
+    let mut up = false;
+    for c in local.chars() {
+        if c == '-' {
+            up = true;
+        } else if up {
+            out.extend(c.to_uppercase());
+            up = false;
+        } else {
+            out.push(c);
+        }
+    }
+    out
+}
+
+/// The attributes of `e` that the package keeps, renamed.
+fn attrs(e: &El) -> Vec<(String, String)> {
+    e.attrs.iter().filter(|(k, _)| keep(k)).map(|(k, v)| (rename(k), v.clone())).collect()
+}
+
+/// A picture's file extension: from its bytes, else from its `wordml://` name.
+fn picture_ext(b: &[u8], name: &str) -> String {
+    let sniffed = if b.starts_with(b"\x89PNG") {
+        "png"
+    } else if b.starts_with(&[0xFF, 0xD8]) {
+        "jpeg"
+    } else if b.starts_with(b"GIF8") {
+        "gif"
+    } else if b.starts_with(b"BM") {
+        "bmp"
+    } else if b.get(40..44) == Some(b" EMF") {
+        "emf"
+    } else if b.starts_with(&[0xD7, 0xCD, 0xC6, 0x9A]) || b.starts_with(&[0x01, 0x00, 0x09, 0x00]) {
+        "wmf"
+    } else {
+        ""
+    };
+    if !sniffed.is_empty() {
+        return sniffed.into();
+    }
+    let ext = name.rsplit_once('.').map(|(_, e)| e.to_ascii_lowercase()).unwrap_or_default();
+    if !ext.is_empty() && ext.len() <= 5 && ext.chars().all(|c| c.is_ascii_alphanumeric()) && ext != "xml" && ext != "rels" {
+        ext
+    } else {
+        "bin".into()
+    }
+}
+
+fn media_type(ext: &str) -> &'static str {
+    match ext {
+        "png" => "image/png",
+        "jpeg" | "jpg" => "image/jpeg",
+        "gif" => "image/gif",
+        "bmp" => "image/bmp",
+        "emf" => "image/x-emf",
+        "wmf" => "image/x-wmf",
+        _ => "application/octet-stream",
+    }
+}
+
+/// `o:DocumentProperties` → `docProps/core.xml`.
+fn core_xml(props: &El) -> Vec<u8> {
+    let mut w = W::new();
+    w.open(
+        "cp:coreProperties",
+        &[
+            ("xmlns:cp", "http://schemas.openxmlformats.org/package/2006/metadata/core-properties"),
+            ("xmlns:dc", "http://purl.org/dc/elements/1.1/"),
+            ("xmlns:dcterms", "http://purl.org/dc/terms/"),
+        ],
+    );
+    for (from, to) in [
+        ("o:Title", "dc:title"),
+        ("o:Subject", "dc:subject"),
+        ("o:Author", "dc:creator"),
+        ("o:Keywords", "cp:keywords"),
+        ("o:Description", "dc:description"),
+        ("o:LastAuthor", "cp:lastModifiedBy"),
+        ("o:Revision", "cp:revision"),
+        ("o:Category", "cp:category"),
+        ("o:Created", "dcterms:created"),
+        ("o:LastSaved", "dcterms:modified"),
+    ] {
+        if let Some(t) = props.child(from).map(El::text).filter(|t| !t.trim().is_empty()) {
+            w.leaf(to, &[], t.trim());
+        }
+    }
+    w.close("cp:coreProperties");
+    w.into_bytes()
+}
diff --git a/crates/docx/src/write/embed.rs b/crates/docx/src/write/embed.rs
index d028a30bbb..5f66f0b4e9 100644
--- a/crates/docx/src/write/embed.rs
+++ b/crates/docx/src/write/embed.rs
@@ -13,7 +13,9 @@ use wordcraft_doc::graphic::Embedded;
 use wordcraft_doc::para::Float;
 
 use super::PartRels;
-use crate::package::{EMBEDDED_PARTS, EmbeddedManifest, MAX_EMBEDDED_PARTS, VBA_PROJECT_PART, VBA_RELATED, relative};
+use crate::package::{
+    CUSTOM_XML_ROOTS, EMBEDDED_PARTS, EmbeddedManifest, MAX_EMBEDDED_PARTS, MAX_EMBEDDED_RELS, VBA_PROJECT_PART, VBA_RELATED, rel_is, relative, rt,
+};
 use crate::units::emu;
 use crate::xml::{self, El, MAX_DEPTH};
 
@@ -64,6 +66,10 @@ impl<'d> EmbedWriter<'d> {
         .map(|s| s.to_string())
         .collect();
         taken.insert(VBA_PROJECT_PART.to_ascii_lowercase());
+        // The bibliography writer uses these names when sources are present (#532).
+        if !doc.sources.is_empty() {
+            taken.extend(["customxml/item1.xml".into(), "customxml/itemprops1.xml".into()]);
+        }
         // The macro project's parts keep their names (see `write_as`).
         if let Some(m) = doc.passthrough.get(VBA_RELATED) {
             for line in String::from_utf8_lossy(m).lines() {
@@ -101,6 +107,9 @@ impl<'d> EmbedWriter<'d> {
 
     /// A free part name for (a copy of) `orig`: `orig` itself if free, else `stem_N.ext`.
     fn alloc(&mut self, orig: &str) -> String {
+        // Suffixes cannot escape reserved directories or a .rels extension. Such a kept
+        // part needs a different base name, otherwise every candidate would be reserved.
+        let orig = if Self::reserved(&orig.to_ascii_lowercase()) { "word/embeddings/part.xml" } else { orig };
         let lower = orig.to_ascii_lowercase();
         if !Self::reserved(&lower) && self.taken.insert(lower) {
             return orig.to_string();
@@ -121,11 +130,61 @@ impl<'d> EmbedWriter<'d> {
         }
     }
 
+    /// A number `n` for which every `{stem}{n}{ext}` is a free part name, with those names taken.
+    fn fresh_set(&mut self, stems: &[&str], ext: &str) -> Vec<String> {
+        let mut n: u32 = 1;
+        loop {
+            let names: Vec<String> = stems.iter().map(|s| format!("{s}{n}{ext}")).collect();
+            if names.iter().all(|name| {
+                let lower = name.to_ascii_lowercase();
+                !Self::reserved(&lower) && !self.taken.contains(&lower)
+            }) {
+                for name in &names {
+                    self.taken.insert(name.to_ascii_lowercase());
+                }
+                return names;
+            }
+            n = n.saturating_add(1);
+        }
+    }
+
+    /// A free part name `{stem}{n}{ext}` for a new part, from n = 1 up.
+    fn fresh(&mut self, stem: &str, ext: &str) -> String {
+        let mut n: u32 = 1;
+        loop {
+            let name = format!("{stem}{n}{ext}");
+            let lower = name.to_ascii_lowercase();
+            if !Self::reserved(&lower) && self.taken.insert(lower) {
+                return name;
+            }
+            n = n.saturating_add(1);
+        }
+    }
+
     /// Can part `name` be written (bytes and manifest entry both kept)?
     fn available(&self, name: &str) -> bool {
         self.manifest.parts.contains_key(name) && self.passthrough.contains_key(name)
     }
 
+    /// Reattach implicit custom XML roots, sharing their kept parts across both owners.
+    pub fn custom_xml_rels(&mut self, owner: &str, rels: &mut PartRels) {
+        let Some(roots) = self.passthrough.get(CUSTOM_XML_ROOTS).cloned() else { return };
+        let mut memo = std::mem::take(&mut self.first);
+        let mut written = Vec::new();
+        for line in String::from_utf8_lossy(&roots).lines().take(MAX_EMBEDDED_RELS * 2) {
+            let fields: Vec<&str> = line.split('\t').collect();
+            let [source, kind, target] = fields.as_slice() else { continue };
+            if *source != owner || !rel_is(kind, rt::CUSTOM_XML) {
+                continue;
+            }
+            if let Some(name) = self.copy_tree(target, &mut memo, &mut written) {
+                let source_part = if owner == "P" { "" } else { STORY_PART };
+                rels.add(kind, &relative(source_part, &name), false);
+            }
+        }
+        self.first = memo;
+    }
+
     /// What copying the parts reached from `roots` costs against the copy budget.
     fn tree_cost(&self, roots: &[&str]) -> u64 {
         let mut seen: HashSet<&str> = HashSet::new();
@@ -191,7 +250,7 @@ impl super::Writer<'_> {
     /// story part's) and the parts it needs queued for writing. `resize`, for an OLE object, writes
     /// the object's current size and position into its own markup (a chart or diagram's frame is
     /// written by the caller). `None` when it can't be written back (its parts are gone).
-    pub(super) fn embedded_xml(&mut self, src: &Embedded, rels: &mut PartRels, resize: Option<(f32, f32, &Float)>) -> Option<String> {
+    pub(super) fn embedded_xml(&mut self, src: &Embedded, rels: &mut PartRels, resize: Option<(f32, f32, &Float, &str)>) -> Option<String> {
         let Some(left) = self.embeds.markup_bytes.checked_sub(src.xml.len() as u64) else {
             log::warn!("docx: too much embedded-object markup; the rest is left out");
             return None;
@@ -243,16 +302,84 @@ impl super::Writer<'_> {
             }
         }
         set_rel_ids(&mut root, &ids, 0);
-        if let Some((w, h, float)) = resize {
-            self.resize_object(&mut root, w, h, float, 0);
+        if let Some((w, h, float, alt)) = resize {
+            self.resize_object(&mut root, w, h, float, alt, 0);
         }
         Some(root.to_xml())
     }
 
+    /// The `a:graphic` of a SmartArt graphic written from its model, laid out `w` × `h` points:
+    /// new diagram parts (`word/diagrams/{data,layout,quickStyle,colors,drawing}N.xml`) related
+    /// from the story part through `rels`.
+    pub(super) fn smart_art_graphic(&mut self, spec: &wordcraft_doc::smart_art::SmartArtSpec, w: f32, h: f32, rels: &mut PartRels) -> String {
+        use crate::package::rt;
+        use crate::smart_art as sa;
+        let names = self.embeds.fresh_set(
+            &["word/diagrams/data", "word/diagrams/layout", "word/diagrams/quickStyle", "word/diagrams/colors", "word/diagrams/drawing"],
+            ".xml",
+        );
+        let [data, layout, style, colors, drawing] = names.as_slice() else { return String::new() };
+        // The drawing first: the data part names it by the story part's relationship id.
+        let drawing_id = rels.add(rt::DIAGRAM_DRAWING, &relative(STORY_PART, drawing), false);
+        let parts = [
+            (data, sa::data_xml(spec, &drawing_id), sa::DATA_CT, rt::DIAGRAM_DATA),
+            (layout, sa::layout_xml(spec.layout), sa::LAYOUT_CT, rt::DIAGRAM_LAYOUT),
+            (style, sa::quick_style_xml(), sa::STYLE_CT, rt::DIAGRAM_QUICK_STYLE),
+            (colors, sa::colors_xml(spec.colors), sa::COLORS_CT, rt::DIAGRAM_COLORS),
+            (drawing, sa::drawing_xml(spec, w, h), sa::DRAWING_CT, rt::DIAGRAM_DRAWING),
+        ];
+        let mut ids = Vec::new();
+        for (name, xml, ct, kind) in parts {
+            self.embeds.parts.push((name.clone(), xml.into_bytes(), ct.to_string(), PartRels::default()));
+            ids.push(rels.add(kind, &relative(STORY_PART, name), false));
+        }
+        let id = |i: usize| ids.get(i).cloned().unwrap_or_default();
+        let mut x = xml::W::default();
+        x.open("a:graphic", &[("xmlns:a", "http://schemas.openxmlformats.org/drawingml/2006/main")]);
+        x.open("a:graphicData", &[("uri", sa::DIAGRAM_URI)]);
+        x.empty(
+            "dgm:relIds",
+            &[
+                ("xmlns:dgm", "http://schemas.openxmlformats.org/drawingml/2006/diagram"),
+                ("xmlns:r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships"),
+                ("r:dm", &id(0)),
+                ("r:lo", &id(1)),
+                ("r:qs", &id(2)),
+                ("r:cs", &id(3)),
+            ],
+        );
+        x.close("a:graphicData");
+        x.close("a:graphic");
+        x.s
+    }
+
+    /// The `a:graphic` of a chart written from its model: a new chart part (`word/charts/chartN.xml`)
+    /// related from the story part through `rels`.
+    pub(super) fn chart_graphic(&mut self, spec: &wordcraft_doc::chart::ChartSpec, rels: &mut PartRels) -> String {
+        let name = self.embeds.fresh("word/charts/chart", ".xml");
+        let bytes = crate::chart_spec::chart_xml(spec).into_bytes();
+        self.embeds.parts.push((name.clone(), bytes, crate::chart_spec::CHART_CT.to_string(), PartRels::default()));
+        let id = rels.add(crate::package::rt::CHART, &relative(STORY_PART, &name), false);
+        let mut w = xml::W::default();
+        w.open("a:graphic", &[("xmlns:a", "http://schemas.openxmlformats.org/drawingml/2006/main")]);
+        w.open("a:graphicData", &[("uri", crate::chart_spec::CHART_URI)]);
+        w.empty(
+            "c:chart",
+            &[
+                ("xmlns:c", "http://schemas.openxmlformats.org/drawingml/2006/chart"),
+                ("xmlns:r", "http://schemas.openxmlformats.org/officeDocument/2006/relationships"),
+                ("r:id", &id),
+            ],
+        );
+        w.close("a:graphicData");
+        w.close("a:graphic");
+        w.s
+    }
+
     /// Write an OLE object's size (and position, when floating), rotation and flips into its VML
     /// shape and DrawingML picture, with the effect extent covering the rotated bounds as for
-    /// other drawings, and give its drawing a fresh `wp:docPr` id.
-    fn resize_object(&mut self, e: &mut El, w: f32, h: f32, float: &Float, depth: usize) {
+    /// other drawings, its alt text into both, and give its drawing a fresh `wp:docPr` id.
+    fn resize_object(&mut self, e: &mut El, w: f32, h: f32, float: &Float, alt: &str, depth: usize) {
         if depth > MAX_DEPTH {
             return;
         }
@@ -261,6 +388,7 @@ impl super::Writer<'_> {
                 if let Some((_, style)) = e.attrs.iter_mut().find(|(k, _)| k == "style") {
                     *style = vml_style_with(style, w, h, float);
                 }
+                set_attr(e, "alt", alt);
             }
             "wp:extent" => set_size_attrs(e, w, h),
             // A turned object needs an effect extent (filled in below) right after its extent.
@@ -299,12 +427,13 @@ impl super::Writer<'_> {
                 if let Some((_, v)) = e.attrs.iter_mut().find(|(k, _)| k == "id") {
                     *v = id;
                 }
+                set_attr(e, "descr", alt);
             }
             _ => {}
         }
         for k in e.kids.iter_mut() {
             if let xml::Node::El(c) = k {
-                self.resize_object(c, w, h, float, depth + 1);
+                self.resize_object(c, w, h, float, alt, depth + 1);
             }
         }
     }
@@ -321,6 +450,15 @@ fn set_size_attrs(e: &mut El, w: f32, h: f32) {
     }
 }
 
+/// Set attribute `k` of `e` to `v` (added when missing; left out when both are empty).
+fn set_attr(e: &mut El, k: &str, v: &str) {
+    match e.attrs.iter_mut().find(|(n, _)| n == k) {
+        Some((_, old)) => *old = v.to_string(),
+        None if !v.is_empty() => e.attrs.push((k.to_string(), v.to_string())),
+        None => {}
+    }
+}
+
 /// Is attribute `k` a relationship id (see `read::embed::rel_ids`)?
 fn is_rel_attr(k: &str) -> bool {
     k.starts_with("r:") || k == "o:relid"
diff --git a/crates/docx/src/write/mod.rs b/crates/docx/src/write/mod.rs
index b31fdf9042..4562ca689a 100644
--- a/crates/docx/src/write/mod.rs
+++ b/crates/docx/src/write/mod.rs
@@ -3,7 +3,9 @@
 mod embed;
 mod math;
 mod props;
+mod sdt;
 mod story;
+mod wordart;
 
 use std::collections::{BTreeMap, HashMap};
 
@@ -42,10 +44,10 @@ impl PartRels {
         }
         self.list.push((id.to_string(), kind.to_string(), target.to_string(), external));
     }
-    fn is_empty(&self) -> bool {
+    pub(crate) fn is_empty(&self) -> bool {
         self.list.is_empty()
     }
-    fn xml(&self) -> Vec<u8> {
+    pub(crate) fn xml(&self) -> Vec<u8> {
         let mut w = W::new();
         w.open("Relationships", &[("xmlns", "http://schemas.openxmlformats.org/package/2006/relationships")]);
         for (id, kind, target, external) in &self.list {
@@ -71,6 +73,8 @@ pub(crate) struct Writer<'d> {
     /// Move ranges open in the output: (revision, range `w:id`, destination?).
     open_moves: Vec<(u32, String, bool)>,
     docpr: u32,
+    /// Shapes' own drawing ids written so far (connectors refer to them).
+    shape_ids: std::collections::HashSet<u32>,
     z: u32,
     /// Note part id → file note id, in first-reference order.
     footnotes: Vec<u32>,
@@ -91,6 +95,8 @@ pub(crate) struct Writer<'d> {
     toc_begin_here: bool,
     /// Close the open TOC field at the end of the paragraph being written.
     toc_end_here: bool,
+    /// Byte offsets of the content control markers the next paragraph writes inline.
+    inline_controls: Vec<usize>,
     /// Media keys actually referenced by a written drawing.
     used_media: std::collections::BTreeSet<String>,
     /// Bounds writing text boxes inside text boxes (as layout shows them).
@@ -111,6 +117,12 @@ pub fn write(doc: &Document) -> Result<Vec<u8>, DocxError> {
 
 /// Write a package of the given flavour (`.docx`, `.docm`, `.dotx`, `.dotm`).
 pub fn write_as(doc: &Document, flavor: Flavor) -> Result<Vec<u8>, DocxError> {
+    zip_entries(&write_parts(doc, flavor)?)
+}
+
+/// The parts of the package [`write_as`] zips, in order, `[Content_Types].xml` first: (part name
+/// without the leading `/`, bytes).
+pub(crate) fn write_parts(doc: &Document, flavor: Flavor) -> Result<Vec<(String, Vec<u8>)>, DocxError> {
     // A range field must be whole in the file: drop markers that lost their partner in editing.
     let balanced;
     let doc = if doc.has_unbalanced_field_ranges() {
@@ -128,7 +140,9 @@ pub fn write_as(doc: &Document, flavor: Flavor) -> Result<Vec<u8>, DocxError> {
         bookmarks: HashMap::new(),
         next_rev_id: 0,
         open_moves: Vec::new(),
-        docpr: 0,
+        // Fresh drawing ids start past the shapes' own (connectors refer to those).
+        docpr: doc.next_shape_id().saturating_sub(1),
+        shape_ids: std::collections::HashSet::new(),
         z: 251_658_240,
         footnotes: Vec::new(),
         endnotes: Vec::new(),
@@ -140,6 +154,7 @@ pub fn write_as(doc: &Document, flavor: Flavor) -> Result<Vec<u8>, DocxError> {
         toc_field: None,
         toc_begin_here: false,
         toc_end_here: false,
+        inline_controls: Vec::new(),
         used_media: Default::default(),
         boxes: wordcraft_doc::BoxBudget::default(),
         embeds: embed::EmbedWriter::new(doc),
@@ -155,6 +170,7 @@ pub fn write_as(doc: &Document, flavor: Flavor) -> Result<Vec<u8>, DocxError> {
     let mut entries: Vec<(String, Vec<u8>)> = Vec::new();
     let mut overrides: Vec<(String, String)> = Vec::new();
     let mut rels = PartRels::default();
+    let mut root = PartRels::default();
 
     // Comments get paragraph ids before any story is written.
     let mut comment_paras: Vec<(u32, String)> = Vec::new();
@@ -330,13 +346,17 @@ pub fn write_as(doc: &Document, flavor: Flavor) -> Result<Vec<u8>, DocxError> {
         push_part(&mut entries, &mut overrides, "word/numbering.xml", numbering_xml(doc), &format!("{CT_WML}numbering+xml"), PartRels::default());
     }
     rels.add(rt::SETTINGS, "settings.xml", false);
+    // The attached template is an external relationship of the settings part (§17.15.1.6).
+    let mut settings_rels = PartRels::default();
+    let template = doc.settings.attached_template.as_deref().map(str::trim).filter(|t| !t.is_empty());
+    let template_rel = template.map(|t| settings_rels.add(rt::ATTACHED_TEMPLATE, t, true));
     push_part(
         &mut entries,
         &mut overrides,
         "word/settings.xml",
-        settings_xml(doc, notes_part(doc, &wr, true), notes_part(doc, &wr, false)),
+        settings_xml(doc, notes_part(doc, &wr, true), notes_part(doc, &wr, false), template_rel.as_deref()),
         &format!("{CT_WML}settings+xml"),
-        PartRels::default(),
+        settings_rels,
     );
     rels.add(rt::THEME, "theme/theme1.xml", false);
     push_part(
@@ -361,7 +381,9 @@ pub fn write_as(doc: &Document, flavor: Flavor) -> Result<Vec<u8>, DocxError> {
         }
     }
 
-    // Parts of charts, diagrams and OLE objects kept from a file, as the objects written need them.
+    wr.embeds.custom_xml_rels("D", &mut rels);
+    wr.embeds.custom_xml_rels("P", &mut root);
+    // Parts of embedded objects and custom XML stores kept from the file.
     for (name, bytes, ct, prels) in std::mem::take(&mut wr.embeds.parts) {
         push_part(&mut entries, &mut overrides, &name, bytes, &ct, prels);
     }
@@ -408,7 +430,6 @@ pub fn write_as(doc: &Document, flavor: Flavor) -> Result<Vec<u8>, DocxError> {
     entries.insert(1, ("word/_rels/document.xml.rels".into(), rels.xml()));
 
     // Package-level parts.
-    let mut root = PartRels::default();
     root.add(rt::OFFICE_DOC, "word/document.xml", false);
     root.add(rt::CORE, "docProps/core.xml", false);
     root.add(rt::APP, "docProps/app.xml", false);
@@ -421,6 +442,27 @@ pub fn write_as(doc: &Document, flavor: Flavor) -> Result<Vec<u8>, DocxError> {
         entries.push(("docProps/custom.xml".into(), crate::custom::write(&doc.custom_props)));
         overrides.push(("/docProps/custom.xml".into(), "application/vnd.openxmlformats-officedocument.custom-properties+xml".into()));
     }
+    if !doc.sources.is_empty() {
+        root.add(rt::CUSTOM_XML, "customXml/item1.xml", false);
+        let mut item_rels = PartRels::default();
+        item_rels.add(rt::CUSTOM_XML_PROPS, "itemProps1.xml", false);
+        push_part(
+            &mut entries,
+            &mut overrides,
+            "customXml/item1.xml",
+            bibliography_xml(doc),
+            "application/vnd.openxmlformats-officedocument.customXml+xml",
+            item_rels,
+        );
+        push_part(
+            &mut entries,
+            &mut overrides,
+            "customXml/itemProps1.xml",
+            bibliography_props_xml(),
+            "application/vnd.openxmlformats-officedocument.customXmlProperties+xml",
+            PartRels::default(),
+        );
+    }
     entries.insert(0, ("_rels/.rels".into(), root.xml()));
 
     // Content types.
@@ -438,8 +480,7 @@ pub fn write_as(doc: &Document, flavor: Flavor) -> Result<Vec<u8>, DocxError> {
     }
     w.close("Types");
     entries.insert(0, ("[Content_Types].xml".into(), w.into_bytes()));
-
-    zip_entries(&entries)
+    Ok(entries)
 }
 
 fn push_part(entries: &mut Vec<(String, Vec<u8>)>, overrides: &mut Vec<(String, String)>, path: &str, bytes: Vec<u8>, ct: &str, rels: PartRels) {
@@ -518,10 +559,15 @@ impl Writer<'_> {
     }
 
     fn next_docpr(&mut self) -> String {
-        self.docpr += 1;
+        self.docpr = self.docpr.saturating_add(1);
         self.docpr.to_string()
     }
 
+    /// The drawing id of a shape: its own (once; a copy gets a fresh one), else a fresh one.
+    fn shape_docpr(&mut self, own: u32) -> String {
+        if own != 0 && self.shape_ids.insert(own) { own.to_string() } else { self.next_docpr() }
+    }
+
     fn bookmark_id(&mut self, name: &str) -> String {
         let n = self.bookmarks.len() as u32;
         self.bookmarks.entry(name.to_string()).or_insert(n).to_string()
@@ -608,11 +654,13 @@ fn styles_xml(doc: &Document) -> Vec<u8> {
     props::rpr_inner(&mut w, &s.default_chr);
     w.close("w:rPr");
     w.close("w:rPrDefault");
-    w.open("w:pPrDefault", &[]);
-    w.open("w:pPr", &[]);
-    props::ppr_inner(&mut w, &s.default_para, false, None);
-    w.close("w:pPr");
-    w.close("w:pPrDefault");
+    if s.default_para_present || s.default_para != wordcraft_doc::props::ParaProps::default() {
+        w.open("w:pPrDefault", &[]);
+        w.open("w:pPr", &[]);
+        props::ppr_inner(&mut w, &s.default_para, false, None);
+        w.close("w:pPr");
+        w.close("w:pPrDefault");
+    }
     w.close("w:docDefaults");
     for st in &s.styles {
         style_xml(&mut w, st);
@@ -663,6 +711,9 @@ fn style_xml(w: &mut W, st: &Style) {
     if st.quick {
         w.empty("w:qFormat", &[]);
     }
+    if st.locked {
+        w.empty("w:locked", &[]);
+    }
     if !st.para.is_empty() && st.kind != StyleKind::Character {
         w.open("w:pPr", &[]);
         props::ppr_inner(w, &st.para, false, None);
@@ -828,7 +879,9 @@ fn notes_part(doc: &Document, wr: &Writer<'_>, foot: bool) -> bool {
     !ids.is_empty() || !seps.is_empty()
 }
 
-fn settings_xml(doc: &Document, footnotes: bool, endnotes: bool) -> Vec<u8> {
+/// `w:settings`, its children in the schema's order (CT_Settings is a sequence). `template_rel`
+/// is the id of the attached template's relationship, when there is one.
+fn settings_xml(doc: &Document, footnotes: bool, endnotes: bool, template_rel: Option<&str>) -> Vec<u8> {
     let s = &doc.settings;
     let s_notes = (&doc.footnote_separators, &doc.endnote_separators);
     let mut w = W::new();
@@ -842,16 +895,46 @@ fn settings_xml(doc: &Document, footnotes: bool, endnotes: bool) -> Vec<u8> {
     if s.mirror_margins {
         w.empty("w:mirrorMargins", &[]);
     }
+    if let Some(id) = template_rel {
+        w.empty("w:attachedTemplate", &[("r:id", id)]);
+    }
+    if s.link_styles {
+        w.empty("w:linkStyles", &[]);
+    }
     if s.track_changes {
         w.empty("w:trackRevisions", &[]);
     }
     if let Some(p) = &s.protection {
-        w.empty("w:documentProtection", &[("w:edit", p), ("w:enforcement", "1")]);
+        let mut a: Vec<(&str, &str)> = Vec::new();
+        if p != "none" {
+            a.push(("w:edit", p));
+        }
+        if s.protect_formatting {
+            a.push(("w:formatting", "1"));
+        }
+        a.push(("w:enforcement", "1"));
+        // Only the hash attributes the reader keeps, each once.
+        for name in crate::read::PROTECTION_HASH_ATTRS {
+            if let Some((_, v)) = s.protect_hash.iter().find(|(k, _)| k == name) {
+                a.push((name, v));
+            }
+        }
+        w.empty("w:documentProtection", &a);
     }
     w.val("w:defaultTabStop", &crate::units::twips(s.default_tab.clamp(1.0, 1584.0)));
     if s.auto_hyphenation {
         w.empty("w:autoHyphenation", &[]);
     }
+    // Schema order: consecutiveHyphenLimit, hyphenationZone, doNotHyphenateCaps.
+    if s.consecutive_hyphen_limit > 0 {
+        w.val("w:consecutiveHyphenLimit", &s.consecutive_hyphen_limit.min(32_767).to_string());
+    }
+    if s.hyphenation_zone.is_finite() && (s.hyphenation_zone - wordcraft_doc::DEFAULT_HYPHENATION_ZONE).abs() > 0.01 {
+        w.val("w:hyphenationZone", &crate::units::twips(s.hyphenation_zone.clamp(0.0, 1584.0)));
+    }
+    if !s.hyphenate_caps {
+        w.empty("w:doNotHyphenateCaps", &[]);
+    }
     if s.even_odd_headers {
         w.empty("w:evenAndOddHeaders", &[]);
     }
@@ -998,3 +1081,211 @@ fn app_xml(doc: &Document) -> Vec<u8> {
     w.close("Properties");
     w.into_bytes()
 }
+
+fn to_source_type(kind: &str) -> &str {
+    match kind.to_ascii_lowercase().as_str() {
+        "book" => "Book",
+        "booksection" | "chapter" => "BookSection",
+        "article" | "journal" | "journalarticle" => "JournalArticle",
+        "periodical" | "articleinaperiodical" => "ArticleInAPeriodical",
+        "website" | "site" | "internetsite" => "InternetSite",
+        "documentfrominternetsite" => "DocumentFromInternetSite",
+        "electronicsource" => "ElectronicSource",
+        "report" => "Report",
+        "conference" | "proceedings" | "conferenceproceedings" => "ConferenceProceedings",
+        "case" => "Case",
+        "art" => "Art",
+        "film" => "Film",
+        "interview" => "Interview",
+        "patent" => "Patent",
+        "performance" => "Performance",
+        "soundrecording" => "SoundRecording",
+        "standard" => "Standard",
+        "thesis" => "Thesis",
+        "other" | "misc" => "Misc",
+        _ => "Book",
+    }
+}
+
+pub(crate) fn from_source_type(st: &str) -> String {
+    match st.trim() {
+        "Book" | "book" => "book".into(),
+        "BookSection" | "booksection" => "bookSection".into(),
+        "JournalArticle" | "journalarticle" | "article" => "article".into(),
+        "ArticleInAPeriodical" | "articleinaperiodical" => "periodical".into(),
+        "InternetSite" | "internetsite" | "website" => "website".into(),
+        "DocumentFromInternetSite" | "documentfrominternetsite" => "website".into(),
+        "ElectronicSource" | "electronicsource" => "electronicsource".into(),
+        "Report" | "report" => "report".into(),
+        "ConferenceProceedings" | "conferenceproceedings" => "conference".into(),
+        "Case" | "case" => "case".into(),
+        "SoundRecording" | "soundrecording" => "soundrecording".into(),
+        "Film" | "film" => "film".into(),
+        "Interview" | "interview" => "interview".into(),
+        "Patent" | "patent" => "patent".into(),
+        "Performance" | "performance" => "performance".into(),
+        "Standard" | "standard" => "standard".into(),
+        "Thesis" | "thesis" => "thesis".into(),
+        "Misc" | "misc" => "other".into(),
+        "" => "book".into(),
+        other => other.to_ascii_lowercase(),
+    }
+}
+
+/// The document's citation style, APA when it has none, and a style sheet file name made from
+/// it (`\APA.XSL`, `\MLA.XSL`).
+fn bib_style(doc: &Document) -> (&str, String) {
+    let name = doc.settings.bib_style.as_deref().map(str::trim).filter(|n| !n.is_empty()).unwrap_or("APA");
+    let file: String = name.chars().filter(char::is_ascii_alphanumeric).collect();
+    (name, format!("\\{}.XSL", if file.is_empty() { "APA" } else { &file }))
+}
+
+fn write_name_list(w: &mut W, names: &str) {
+    w.open("b:NameList", &[]);
+    let persons: Vec<_> = names.split(';').map(str::trim).filter(|s| !s.is_empty()).collect();
+    for a in persons {
+        w.open("b:Person", &[]);
+        // Parse "Last, First" or "Last, First Middle"
+        let (last, first_middle) = match a.split_once(',') {
+            Some((l, f)) => (l.trim(), f.trim()),
+            None => (a, ""),
+        };
+        w.leaf("b:Last", &[], last);
+        if !first_middle.is_empty() {
+            let parts: Vec<&str> = first_middle.split_whitespace().collect();
+            if let Some(first) = parts.first() {
+                w.leaf("b:First", &[], first);
+            }
+            if let Some(slice) = parts.get(1..).filter(|s| !s.is_empty()) {
+                let mid = slice.join(" ");
+                w.leaf("b:Middle", &[], &mid);
+            }
+        }
+        w.close("b:Person");
+    }
+    w.close("b:NameList");
+}
+
+fn split_accessed_date(s: &str) -> (Option<&str>, Option<&str>, Option<&str>) {
+    let s = s.trim();
+    if s.is_empty() {
+        return (None, None, None);
+    }
+    let parts: Vec<&str> = if s.contains('-') {
+        s.split('-').collect()
+    } else if s.contains('/') {
+        s.split('/').collect()
+    } else {
+        Vec::new()
+    };
+    if let [y, m, d] = parts.as_slice() {
+        (Some(y.trim()), Some(m.trim()), Some(d.trim()))
+    } else if let [y, m] = parts.as_slice() {
+        (Some(y.trim()), Some(m.trim()), None)
+    } else {
+        (Some(s), None, None)
+    }
+}
+
+fn bibliography_xml(doc: &Document) -> Vec<u8> {
+    let (style_name, selected) = bib_style(doc);
+    let mut w = W::new();
+    w.open(
+        "b:Sources",
+        &[
+            ("SelectedStyle", selected.as_str()),
+            ("StyleName", style_name),
+            ("xmlns:b", "http://schemas.openxmlformats.org/officeDocument/2006/bibliography"),
+            ("xmlns", "http://schemas.openxmlformats.org/officeDocument/2006/bibliography"),
+        ],
+    );
+    for src in &doc.sources {
+        w.open("b:Source", &[]);
+        w.leaf("b:Tag", &[], &src.tag);
+        w.leaf("b:SourceType", &[], to_source_type(&src.kind));
+        // Author & Editor
+        if !src.author.is_empty() || !src.editor.is_empty() {
+            w.open("b:Author", &[]);
+            if !src.author.is_empty() {
+                w.open("b:Author", &[]);
+                write_name_list(&mut w, &src.author);
+                w.close("b:Author");
+            }
+            if !src.editor.is_empty() {
+                w.open("b:Editor", &[]);
+                write_name_list(&mut w, &src.editor);
+                w.close("b:Editor");
+            }
+            w.close("b:Author");
+        }
+        if !src.title.is_empty() {
+            w.leaf("b:Title", &[], &src.title);
+        }
+        if !src.year.is_empty() {
+            w.leaf("b:Year", &[], &src.year);
+        }
+        if !src.month.is_empty() {
+            w.leaf("b:Month", &[], &src.month);
+        }
+        if !src.day.is_empty() {
+            w.leaf("b:Day", &[], &src.day);
+        }
+        if !src.city.is_empty() {
+            w.leaf("b:City", &[], &src.city);
+        }
+        if !src.publisher.is_empty() {
+            w.leaf("b:Publisher", &[], &src.publisher);
+        }
+        if !src.journal.is_empty() {
+            w.leaf("b:JournalName", &[], &src.journal);
+        }
+        if !src.edition.is_empty() {
+            w.leaf("b:Edition", &[], &src.edition);
+        }
+        if !src.volume.is_empty() {
+            w.leaf("b:Volume", &[], &src.volume);
+        }
+        if !src.issue.is_empty() {
+            w.leaf("b:Issue", &[], &src.issue);
+        }
+        if !src.pages.is_empty() {
+            w.leaf("b:Pages", &[], &src.pages);
+        }
+        if !src.url.is_empty() {
+            w.leaf("b:URL", &[], &src.url);
+        }
+        if !src.accessed.is_empty() {
+            let (y, m, d) = split_accessed_date(&src.accessed);
+            if let Some(y) = y.filter(|s| !s.is_empty()) {
+                w.leaf("b:YearAccessed", &[], y);
+            }
+            if let Some(m) = m.filter(|s| !s.is_empty()) {
+                w.leaf("b:MonthAccessed", &[], m);
+            }
+            if let Some(d) = d.filter(|s| !s.is_empty()) {
+                w.leaf("b:DayAccessed", &[], d);
+            }
+            w.leaf("b:Accessed", &[], &src.accessed);
+        }
+        if !src.doi.is_empty() {
+            w.leaf("b:DOI", &[], &src.doi);
+            w.leaf("b:StandardNumber", &[], &src.doi);
+        }
+        w.close("b:Source");
+    }
+    w.close("b:Sources");
+    w.into_bytes()
+}
+
+fn bibliography_props_xml() -> Vec<u8> {
+    let mut w = W::new();
+    w.open(
+        "ds:datastoreItem",
+        &[("xmlns:ds", "http://schemas.openxmlformats.org/officeDocument/2006/customXml"), ("ds:itemID", "{3315B9A8-2323-4554-B8B2-1234567890AB}")],
+    );
+    w.open("ds:schemaRefs", &[]);
+    w.empty("ds:schemaRef", &[("ds:uri", "http://schemas.openxmlformats.org/officeDocument/2006/bibliography")]);
+    w.close("ds:schemaRefs");
+    w.close("ds:datastoreItem");
+    w.into_bytes()
+}
diff --git a/crates/docx/src/write/props.rs b/crates/docx/src/write/props.rs
index 5a90ea9447..b9e083793f 100644
--- a/crates/docx/src/write/props.rs
+++ b/crates/docx/src/write/props.rs
@@ -29,11 +29,18 @@ pub fn rpr_inner(w: &mut W, c: &CharProps) {
     // The complex-script font is written only when set: without it, Persian/Arabic text keeps
     // the style's. Complex-script bold, italic and size default to the plain ones (they come in
     // pairs, see `CharProps::overlay`), so text formatted here looks the same in Word.
-    match (&c.font, &c.font_cs) {
-        (Some(f), Some(cs)) => w.empty("w:rFonts", &[("w:ascii", f), ("w:hAnsi", f), ("w:cs", cs)]),
-        (Some(f), None) => w.empty("w:rFonts", &[("w:ascii", f), ("w:hAnsi", f)]),
-        (None, Some(cs)) => w.empty("w:rFonts", &[("w:cs", cs)]),
-        (None, None) => {}
+    let mut fonts: Vec<(&str, &str)> = Vec::new();
+    if let Some(f) = &c.font {
+        fonts.extend([("w:ascii", f.as_str()), ("w:hAnsi", f.as_str())]);
+    }
+    if let Some(ea) = &c.font_ea {
+        fonts.push(("w:eastAsia", ea));
+    }
+    if let Some(cs) = &c.font_cs {
+        fonts.push(("w:cs", cs));
+    }
+    if !fonts.is_empty() {
+        w.empty("w:rFonts", &fonts);
     }
     toggle(w, "w:b", c.bold);
     toggle(w, "w:bCs", c.bold_cs.or(c.bold));
@@ -106,6 +113,9 @@ pub fn rpr_inner(w: &mut W, c: &CharProps) {
         (None, Some(b)) => w.empty("w:lang", &[("w:bidi", b)]),
         (None, None) => {}
     }
+    if let Some(fx) = &c.text_effects {
+        super::wordart::rpr_effects(w, fx);
+    }
 }
 
 /// Does `c` produce any `w:rPr` content (besides a tracked change)?
@@ -279,23 +289,37 @@ pub fn ppr_inner(w: &mut W, p: &ParaProps, framed: bool, num_change: Option<&Cha
         }
         w.empty("w:spacing", &a);
     }
-    if p.indent_left.is_some() || p.indent_right.is_some() || p.indent_first.is_some() {
+    let chars = [p.indent_left_chars, p.indent_right_chars, p.indent_first_chars];
+    if p.indent_left.is_some() || p.indent_right.is_some() || p.indent_first.is_some() || chars.iter().any(Option::is_some) {
         let l = p.indent_left.map(twips);
         let r = p.indent_right.map(twips);
         let f = p.indent_first.map(|v| (v < 0.0, twips(v.abs())));
+        // Character units in hundredths of a character.
+        let hundredths = |v: f32| ((v.clamp(-1584.0, 1584.0) * 100.0).round() as i64).to_string();
+        let [lc, rc, fc] = chars.map(|c| c.map(|v| (v < 0.0, hundredths(v.abs()), hundredths(v))));
         let mut a: Vec<(&str, &str)> = Vec::new();
+        if let Some((_, _, v)) = &lc {
+            a.push(("w:leftChars", v));
+        }
         if let Some(l) = &l {
             a.push(("w:left", l));
         }
+        if let Some((_, _, v)) = &rc {
+            a.push(("w:rightChars", v));
+        }
         if let Some(r) = &r {
             a.push(("w:right", r));
         }
+        if let Some((hang, v, _)) = &fc {
+            a.push((if *hang { "w:hangingChars" } else { "w:firstLineChars" }, v));
+        }
         if let Some((hang, v)) = &f {
             a.push((if *hang { "w:hanging" } else { "w:firstLine" }, v));
         }
         w.empty("w:ind", &a);
     }
     toggle(w, "w:contextualSpacing", p.contextual_spacing);
+    toggle(w, "w:mirrorIndents", p.mirror_indents);
     if let Some(a) = p.align {
         w.val("w:jc", align_val(a));
     }
@@ -395,6 +419,9 @@ fn tblpr_inner(w: &mut W, t: &TableProps) {
     if let Some(c) = &t.caption {
         w.val("w:tblCaption", c);
     }
+    if let Some(d) = &t.description {
+        w.val("w:tblDescription", d);
+    }
 }
 
 /// `w:trPr` (when the row has any), with a tracked change last as for [`tblpr`].
diff --git a/crates/docx/src/write/sdt.rs b/crates/docx/src/write/sdt.rs
new file mode 100644
index 0000000000..7f377c8457
--- /dev/null
+++ b/crates/docx/src/write/sdt.rs
@@ -0,0 +1,281 @@
+//! Content controls → `w:sdt` (ECMA-376 §17.5.2; check boxes and repeating sections as the
+//! [MS-DOCX] `w14`/`w15` extensions).
+//!
+//! Controls are markers in the model ([`wordcraft_doc::control`]); the file wants them as
+//! elements around runs (inline) or around whole paragraphs and tables (block level). [`plan`]
+//! decides, per block list, which controls are written where so that the XML always nests.
+
+use std::collections::HashSet;
+
+use wordcraft_doc::Blocks;
+use wordcraft_doc::control::{ContentControl, ControlEvent, ControlKind, control_events, pair_events};
+use wordcraft_doc::para::OBJ;
+
+use crate::xml::W;
+
+/// Where a block list's controls are written.
+#[derive(Default)]
+pub struct Plan<'a> {
+    /// Controls opening before block `i` (outermost first).
+    pub opens: Vec<Vec<&'a ContentControl>>,
+    /// Controls closing after block `i`.
+    pub closes: Vec<u32>,
+    /// Paragraph markers written inline, as (block, byte offset).
+    pub inline: HashSet<(usize, usize)>,
+}
+
+impl Plan<'_> {
+    /// Whether a block-level control is around block `i`.
+    pub fn covers(&self, i: usize) -> bool {
+        let mut open = 0i64;
+        for k in 0..=i {
+            open += self.opens.get(k).map(|v| v.len() as i64).unwrap_or(0);
+            if k < i {
+                open -= i64::from(self.closes.get(k).copied().unwrap_or(0));
+            }
+        }
+        open > 0
+    }
+    /// The byte offsets of paragraph `i`'s markers that are written inline.
+    pub fn inline_in(&self, i: usize) -> Vec<usize> {
+        let mut v: Vec<usize> = self.inline.iter().filter(|(b, _)| *b == i).map(|(_, o)| *o).collect();
+        v.sort_unstable();
+        v
+    }
+}
+
+#[derive(Clone, Copy, PartialEq)]
+enum Mode {
+    Inline,
+    Block,
+}
+
+/// Plan the controls of a block list (not looking into cells: they have their own lists).
+/// Markers without a partner are not written.
+pub fn plan(bl: &Blocks) -> Plan<'_> {
+    let n = bl.len();
+    let mut out = Plan { opens: vec![Vec::new(); n], closes: vec![0; n], inline: HashSet::new() };
+    let events = control_events(bl);
+    if events.is_empty() {
+        return out;
+    }
+    let (pairs, _) = pair_events(&events);
+    // Ranges in the order they open (parents before children).
+    let mut ranges: Vec<(usize, usize)> = pairs.iter().map(|(o, c, _)| (*o, *c)).collect();
+    ranges.sort_unstable();
+    // Parent of each range: the innermost one opened before it and closed after it.
+    let mut parent: Vec<Option<usize>> = vec![None; ranges.len()];
+    let mut stack: Vec<usize> = Vec::new();
+    for (k, (o, _)) in ranges.iter().enumerate() {
+        while let Some(&top) = stack.last() {
+            if ranges.get(top).is_some_and(|(_, tc)| tc < o) {
+                stack.pop();
+            } else {
+                break;
+            }
+        }
+        if let Some(slot) = parent.get_mut(k) {
+            *slot = stack.last().copied();
+        }
+        stack.push(k);
+    }
+    let para = |b: usize| bl.get(b).and_then(|x| x.as_para());
+    // Only control starts before `off` in the paragraph / only control ends after it.
+    let at_start = |b: usize, off: usize| {
+        para(b).is_some_and(|p| {
+            p.text.get(..off).is_some_and(|t| t.chars().all(|c| c == OBJ))
+                && (0..off).step_by(OBJ.len_utf8()).all(|o| matches!(p.object_at(o), Some(wordcraft_doc::InlineObject::ControlStart { .. })))
+        })
+    };
+    let at_end = |b: usize, off: usize| {
+        para(b).is_some_and(|p| {
+            let from = off + OBJ.len_utf8();
+            p.text.get(from..).is_some_and(|t| t.chars().all(|c| c == OBJ))
+                && (from..p.len()).step_by(OBJ.len_utf8()).all(|o| matches!(p.object_at(o), Some(wordcraft_doc::InlineObject::ControlEnd)))
+        })
+    };
+    let mut mode = vec![Mode::Inline; ranges.len()];
+    let mut span: Vec<(usize, usize)> = vec![(0, 0); ranges.len()];
+    for (k, (o, c)) in ranges.iter().enumerate() {
+        let (Some(ControlEvent::Open { block: sb, off: so, control }), Some(e)) = (events.get(*o), events.get(*c)) else { continue };
+        let (eb, eo) = (e.block(), e.off());
+        let m = match (so, eo) {
+            (Some(so), Some(eo)) if *sb == eb => {
+                let parent_inline = parent.get(k).copied().flatten().and_then(|p| mode.get(p)).is_some_and(|m| *m == Mode::Inline);
+                if !parent_inline && control.block && at_start(*sb, *so) && at_end(eb, eo) { Mode::Block } else { Mode::Inline }
+            }
+            _ => Mode::Block,
+        };
+        if let Some(slot) = mode.get_mut(k) {
+            *slot = m;
+        }
+        if let Some(slot) = span.get_mut(k) {
+            *slot = (*sb, eb);
+        }
+    }
+    // Block-level controls nest by block: one that opens in the block another (not its
+    // ancestor) closes after starts with the next block instead.
+    for k in 0..ranges.len() {
+        if mode.get(k) != Some(&Mode::Block) {
+            continue;
+        }
+        let Some(&(o, _)) = ranges.get(k) else { continue };
+        let Some(&(sb, eb)) = span.get(k) else { continue };
+        let clash = ranges
+            .iter()
+            .enumerate()
+            .any(|(q, (_, qc))| q != k && *qc < o && mode.get(q) == Some(&Mode::Block) && span.get(q).is_some_and(|s| s.1 == sb));
+        if clash {
+            let to = (sb + 1).min(eb);
+            if let Some(s) = span.get_mut(k) {
+                s.0 = to;
+            }
+        }
+    }
+    for (k, (o, c)) in ranges.iter().enumerate() {
+        let Some(ControlEvent::Open { control, .. }) = events.get(*o) else { continue };
+        match mode.get(k) {
+            Some(Mode::Block) => {
+                let Some(&(sb, eb)) = span.get(k) else { continue };
+                if let Some(v) = out.opens.get_mut(sb) {
+                    v.push(control);
+                }
+                if let Some(x) = out.closes.get_mut(eb) {
+                    *x += 1;
+                }
+            }
+            _ => {
+                for e in [events.get(*o), events.get(*c)].into_iter().flatten() {
+                    if let Some(off) = e.off() {
+                        out.inline.insert((e.block(), off));
+                    }
+                }
+            }
+        }
+    }
+    out
+}
+
+fn on(w: &mut W, name: &str, v: bool) {
+    if v {
+        w.empty(name, &[]);
+    }
+}
+
+/// `w:sdtPr` (and `w:sdtEndPr`), then open `w:sdtContent`.
+pub fn open(w: &mut W, c: &ContentControl) {
+    w.open("w:sdt", &[]);
+    w.open("w:sdtPr", &[]);
+    w.raw(&c.rpr_xml);
+    if !c.title.is_empty() {
+        w.val("w:alias", &c.title);
+    }
+    if !c.tag.is_empty() {
+        w.val("w:tag", &c.tag);
+    }
+    if let Some(id) = c.id {
+        w.val("w:id", &id.to_string());
+    }
+    if let Some(l) = c.lock.ooxml() {
+        w.val("w:lock", l);
+    }
+    if !c.placeholder.is_empty() {
+        w.open("w:placeholder", &[]);
+        w.val("w:docPart", &c.placeholder);
+        w.close("w:placeholder");
+    }
+    on(w, "w:temporary", c.temporary);
+    on(w, "w:showingPlcHdr", c.showing_placeholder);
+    // Kept elements of the schema's sequence before the type, then the type, then the rest.
+    let early = |x: &&String| {
+        ["<w:dataBinding", "<w:label", "<w:tabIndex"].iter().any(|n| x.strip_prefix(n).is_some_and(|rest| rest.starts_with([' ', '/', '>'])))
+    };
+    for x in c.extra.iter().filter(early) {
+        w.raw(x);
+    }
+    kind(w, &c.kind);
+    for x in c.extra.iter().filter(|x| !early(x)) {
+        w.raw(x);
+    }
+    w.close("w:sdtPr");
+    w.raw(&c.end_pr_xml);
+    w.open("w:sdtContent", &[]);
+}
+
+/// Close `w:sdtContent` and `w:sdt`.
+pub fn close(w: &mut W) {
+    w.raw("</w:sdtContent></w:sdt>");
+}
+
+fn kind(w: &mut W, k: &ControlKind) {
+    match k {
+        ControlKind::RichText => {}
+        ControlKind::Text { multi_line } => {
+            if *multi_line {
+                w.empty("w:text", &[("w:multiLine", "1")]);
+            } else {
+                w.empty("w:text", &[]);
+            }
+        }
+        ControlKind::CheckBox { checked, checked_char, checked_font, unchecked_char, unchecked_font } => {
+            w.open("w14:checkbox", &[]);
+            w.empty("w14:checked", &[("w14:val", if *checked { "1" } else { "0" })]);
+            for (tag, ch, font) in [("w14:checkedState", checked_char, checked_font), ("w14:uncheckedState", unchecked_char, unchecked_font)] {
+                let hex = format!("{:04X}", u32::from(*ch));
+                if font.is_empty() {
+                    w.empty(tag, &[("w14:val", &hex)]);
+                } else {
+                    w.empty(tag, &[("w14:val", &hex), ("w14:font", font)]);
+                }
+            }
+            w.close("w14:checkbox");
+        }
+        ControlKind::ComboBox { items, last_value } | ControlKind::DropDown { items, last_value } => {
+            let tag = if matches!(k, ControlKind::ComboBox { .. }) { "w:comboBox" } else { "w:dropDownList" };
+            if last_value.is_empty() {
+                w.open(tag, &[]);
+            } else {
+                w.open(tag, &[("w:lastValue", last_value)]);
+            }
+            for i in items {
+                w.empty("w:listItem", &[("w:displayText", &i.display), ("w:value", i.value())]);
+            }
+            w.close(tag);
+        }
+        ControlKind::Date { full_date, format, lid, calendar, store_as } => {
+            if full_date.is_empty() {
+                w.open("w:date", &[]);
+            } else {
+                w.open("w:date", &[("w:fullDate", full_date)]);
+            }
+            for (tag, v) in [("w:dateFormat", format), ("w:lid", lid), ("w:storeMappedDataAs", store_as), ("w:calendar", calendar)] {
+                if !v.is_empty() {
+                    w.val(tag, v);
+                }
+            }
+            w.close("w:date");
+        }
+        ControlKind::Picture => w.empty("w:picture", &[]),
+        ControlKind::Gallery { list, gallery, category, unique } => {
+            let tag = if *list { "w:docPartList" } else { "w:docPartObj" };
+            w.open(tag, &[]);
+            if !gallery.is_empty() {
+                w.val("w:docPartGallery", gallery);
+            }
+            if !category.is_empty() {
+                w.val("w:docPartCategory", category);
+            }
+            on(w, "w:docPartUnique", *unique);
+            w.close(tag);
+        }
+        ControlKind::RepeatingSection { title, no_insert_delete } => {
+            w.open("w15:repeatingSection", &[]);
+            if !title.is_empty() {
+                w.val("w15:sectionTitle", title);
+            }
+            on(w, "w15:doNotAllowInsertDeleteSection", *no_insert_delete);
+            w.close("w15:repeatingSection");
+        }
+        ControlKind::RepeatingSectionItem => w.empty("w15:repeatingSectionItem", &[]),
+    }
+}
diff --git a/crates/docx/src/write/story.rs b/crates/docx/src/write/story.rs
index 903765885b..508f4fdbd7 100644
--- a/crates/docx/src/write/story.rs
+++ b/crates/docx/src/write/story.rs
@@ -1,7 +1,7 @@
 //! Blocks, paragraphs, runs, objects and tables → WordprocessingML.
 
 use wordcraft_doc::effects::ShapeEffects;
-use wordcraft_doc::para::{Anchor, Float, NoteKind, ShapeKind, Wrap};
+use wordcraft_doc::para::{AltText, Anchor, Float, NoteKind, ShapeKind, Wrap};
 use wordcraft_doc::props::{CharProps, PropChange, Rgb};
 use wordcraft_doc::section::{LineNumberRestart, NoteProps, SectionProps, SectionStart};
 use wordcraft_doc::table::Table;
@@ -21,7 +21,8 @@ enum Piece<'a> {
     Br(Option<&'static str>),
     NbHyphen,
     SoftHyphen,
-    Obj(&'a InlineObject),
+    /// An object and its byte offset in the paragraph.
+    Obj(&'a InlineObject, usize),
 }
 
 impl Writer<'_> {
@@ -31,10 +32,15 @@ impl Writer<'_> {
             w.raw("<w:p/>");
             return;
         }
-        let toc = if top { toc_span(bl) } else { None };
+        let plan = super::sdt::plan(bl);
+        // A TOC inside a content control already has one (read from a file).
+        let toc = if top { toc_span(bl).filter(|(start, _)| !plan.covers(*start)) } else { None };
         // Whether the heading's TOC field was written and still needs its end.
         let mut toc_field_open = false;
         for (i, b) in bl.iter().enumerate() {
+            for c in plan.opens.get(i).into_iter().flatten() {
+                super::sdt::open(w, c);
+            }
             if let Some((start, end)) = toc {
                 if i == start {
                     w.raw(TOC_SDT_OPEN);
@@ -44,7 +50,10 @@ impl Writer<'_> {
                 self.toc_end_here = toc_field_open && i == end;
             }
             match &**b {
-                Block::Para(p) => self.para(w, p, rels, top, depth),
+                Block::Para(p) => {
+                    self.inline_controls = plan.inline_in(i);
+                    self.para(w, p, rels, top, depth);
+                }
                 Block::Table(t) => self.table(w, t, rels, depth),
             }
             if let Some((start, end)) = toc {
@@ -57,6 +66,9 @@ impl Writer<'_> {
                     w.raw("</w:sdtContent></w:sdt>");
                 }
             }
+            for _ in 0..plan.closes.get(i).copied().unwrap_or(0) {
+                super::sdt::close(w);
+            }
         }
         if depth == 0 {
             self.move_ranges(w, &[]);
@@ -105,6 +117,8 @@ impl Writer<'_> {
     }
 
     fn para(&mut self, w: &mut W, p: &Paragraph, rels: &mut PartRels, top: bool, depth: usize) {
+        // Which content control markers are written inline (set by `blocks`).
+        let inline = std::mem::take(&mut self.inline_controls);
         // A drop cap is a separate framed paragraph holding the first character.
         if let Some(lines) = p.props.drop_cap.filter(|l| *l > 0)
             && let Some(first) = p.text.chars().next().filter(|c| !matches!(*c, wordcraft_doc::para::OBJ | '\t' | '\n' | '\u{c}' | '\u{e}'))
@@ -118,10 +132,12 @@ impl Writer<'_> {
                 self.para_inner(w, &head, rels, false, depth, true);
                 tail.props.drop_cap = None;
                 tail.section = p.section.clone();
+                self.inline_controls = inline.iter().filter_map(|o| o.checked_sub(first.len_utf8())).collect();
                 self.para_inner(w, &tail, rels, top, depth, false);
                 return;
             }
         }
+        self.inline_controls = inline;
         self.para_inner(w, p, rels, top, depth, false);
     }
 
@@ -211,13 +227,16 @@ impl Writer<'_> {
     }
 
     fn para_content(&mut self, w: &mut W, p: &Paragraph, rels: &mut PartRels, depth: usize) {
+        // Taken first: a text box in this paragraph writes paragraphs of its own.
+        let inline = std::mem::take(&mut self.inline_controls);
         // Split into pieces with their props.
         let mut pieces: Vec<(Piece, &CharProps)> = Vec::new();
         let mut k = 0usize;
         for (range, props) in p.run_ranges() {
+            let base = range.start;
             let Some(text) = p.text.get(range) else { continue };
             let mut buf = String::new();
-            for c in text.chars() {
+            for (ci, c) in text.char_indices() {
                 let special = match c {
                     '\t' => Some(Piece::Tab),
                     '\n' => Some(Piece::Br(None)),
@@ -229,7 +248,7 @@ impl Writer<'_> {
                         let o = p.objects.get(k);
                         k += 1;
                         Some(match o {
-                            Some(o) => Piece::Obj(o),
+                            Some(o) => Piece::Obj(o, base + ci),
                             None => Piece::Text(String::new()),
                         })
                     }
@@ -255,6 +274,22 @@ impl Writer<'_> {
         while i < pieces.len() {
             let Some((piece, props)) = pieces.get(i) else { break };
             let props: &CharProps = props;
+            // Content control boundaries: written inline when the plan says so (else they are
+            // written around the paragraph, or were left without a partner). A hyperlink never
+            // crosses one.
+            if let Piece::Obj(o @ (InlineObject::ControlStart { .. } | InlineObject::ControlEnd), off) = piece {
+                if inline.binary_search(off).is_ok() {
+                    if open_link.take().is_some() {
+                        w.close("w:hyperlink");
+                    }
+                    match o {
+                        InlineObject::ControlStart { control } => super::sdt::open(w, control),
+                        _ => super::sdt::close(w),
+                    }
+                }
+                i += 1;
+                continue;
+            }
             // Hyperlink grouping.
             if props.link != open_link {
                 if open_link.is_some() {
@@ -272,7 +307,7 @@ impl Writer<'_> {
                 }
             }
             match piece {
-                Piece::Obj(o) => {
+                Piece::Obj(o, _) => {
                     self.object(w, o, props, rels, depth);
                     i += 1;
                 }
@@ -280,7 +315,7 @@ impl Writer<'_> {
                     // Gather simple pieces sharing these props into one run.
                     let mut j = i;
                     while let Some((pc, pr)) = pieces.get(j) {
-                        if matches!(pc, Piece::Obj(_)) || !(std::ptr::eq(*pr, props) || *pr == props) {
+                        if matches!(pc, Piece::Obj(..)) || !(std::ptr::eq(*pr, props) || *pr == props) {
                             break;
                         }
                         j += 1;
@@ -395,6 +430,8 @@ impl Writer<'_> {
 
     fn object(&mut self, w: &mut W, o: &InlineObject, props: &CharProps, rels: &mut PartRels, depth: usize) {
         match o {
+            // Written by `para_content` (inline) or `blocks` (around paragraphs).
+            InlineObject::ControlStart { .. } | InlineObject::ControlEnd => {}
             InlineObject::BookmarkStart { name } => {
                 let id = self.bookmark_id(name);
                 w.empty("w:bookmarkStart", &[("w:id", &id), ("w:name", name)]);
@@ -403,6 +440,18 @@ impl Writer<'_> {
                 let id = self.bookmark_id(name);
                 w.empty("w:bookmarkEnd", &[("w:id", &id)]);
             }
+            InlineObject::PermStart { id, group, editor } => {
+                let id = id.to_string();
+                let mut a = vec![("w:id", id.as_str())];
+                if !group.is_empty() {
+                    a.push(("w:edGrp", group.as_str()));
+                }
+                if !editor.is_empty() {
+                    a.push(("w:ed", editor.as_str()));
+                }
+                w.empty("w:permStart", &a);
+            }
+            InlineObject::PermEnd { id } => w.empty("w:permEnd", &[("w:id", &id.to_string())]),
             InlineObject::CommentStart { id } => {
                 if self.doc.comments.contains_key(id) {
                     w.empty("w:commentRangeStart", &[("w:id", &id.to_string())]);
@@ -476,10 +525,23 @@ impl Writer<'_> {
                 self.rev_close(w, props);
             }
             // A chart or diagram read from a file: its frame from the object's size and position,
-            // the graphic inside as read. Ones made some other way have nothing to write.
+            // the graphic inside as read. Ones made some other way have nothing to write, except
+            // charts and SmartArt with a model (made or edited in WordCraft): their parts are
+            // written from it.
             InlineObject::Graphic { w: gw, h: gh, alt, float, graphic } => {
-                let Some(src) = graphic.source.as_deref() else { return };
-                let Some(inner) = self.embedded_xml(src, rels, None) else { return };
+                let inner = match (graphic.chart.as_deref(), graphic.smart_art.as_deref(), graphic.source.as_deref()) {
+                    // A chart WordCraft can edit: a chart part written from its model.
+                    (Some(spec), _, _) => self.chart_graphic(spec, rels),
+                    (None, Some(spec), _) => self.smart_art_graphic(spec, *gw, *gh, rels),
+                    (None, None, Some(src)) => {
+                        let Some(inner) = self.embedded_xml(src, rels, None) else { return };
+                        inner
+                    }
+                    (None, None, None) => return,
+                };
+                if inner.is_empty() {
+                    return;
+                }
                 self.rev_open(w, props);
                 w.open("w:r", &[]);
                 self.rpr(w, props);
@@ -500,7 +562,7 @@ impl Writer<'_> {
             InlineObject::Image { media, w: iw, h: ih, alt, float, ole, .. } => {
                 // An OLE object read from a file: the object itself, at its current size.
                 if let Some(src) = ole.as_deref()
-                    && let Some(obj) = self.embedded_xml(src, rels, Some((*iw, *ih, float)))
+                    && let Some(obj) = self.embedded_xml(src, rels, Some((*iw, *ih, float, alt.as_str())))
                 {
                     self.rev_open(w, props);
                     w.open("w:r", &[]);
@@ -529,12 +591,12 @@ impl Writer<'_> {
                 w.close("w:r");
                 self.rev_close(w, props);
             }
-            InlineObject::Shape { kind, w: sw, h: sh, float, effects, freeform, .. } => {
+            InlineObject::Shape { kind, w: sw, h: sh, float, effects, freeform, extra, .. } => {
                 self.rev_open(w, props);
                 w.open("w:r", &[]);
                 self.rpr(w, props);
                 w.open("w:drawing", &[]);
-                let docpr = self.next_docpr();
+                let docpr = self.shape_docpr(extra.id);
                 // Ink is told apart by its name (and its pen), which reading looks for.
                 let name = shape_name(*kind, freeform.as_deref(), &docpr);
                 // The effect extent leaves room for the shadow and glow.
@@ -549,7 +611,7 @@ impl Writer<'_> {
                         .map(std::sync::Arc::new);
                 }
                 let float = &float;
-                self.drawing_open(w, float, *sw, *sh, &docpr, &name, "");
+                self.drawing_open(w, float, *sw, *sh, &docpr, &name, o.alt_text());
                 w.empty("wp:cNvGraphicFramePr", &[]);
                 w.open("a:graphic", &[]);
                 w.open("a:graphicData", &[("uri", "http://schemas.microsoft.com/office/word/2010/wordprocessingShape")]);
@@ -568,7 +630,7 @@ impl Writer<'_> {
                 w.open("w:drawing", &[]);
                 let docpr = self.next_docpr();
                 let name = format!("{} {docpr}", if canvas.is_some() { "Canvas" } else { "Group" });
-                self.drawing_open(w, float, *gw, *gh, &docpr, &name, "");
+                self.drawing_open(w, float, *gw, *gh, &docpr, &name, o.alt_text());
                 w.empty("wp:cNvGraphicFramePr", &[]);
                 w.open("a:graphic", &[]);
                 let outer = match canvas {
@@ -615,8 +677,8 @@ impl Writer<'_> {
                                 self.pic(w, &c.obj, &file, at, rels);
                             }
                         }
-                        InlineObject::Shape { .. } => {
-                            let id = self.next_docpr();
+                        InlineObject::Shape { extra, .. } => {
+                            let id = self.shape_docpr(extra.id);
                             self.wsp(w, &c.obj, Some(&id), at, rels, depth);
                         }
                         _ => {}
@@ -812,7 +874,7 @@ impl Writer<'_> {
         self.used_media.insert(media.clone());
         w.open("pic:pic", &[]);
         w.open("pic:nvPicPr", &[]);
-        w.empty("pic:cNvPr", &[("id", "0"), ("name", file), ("descr", alt)]);
+        nv_props(w, "pic:cNvPr", "0", file, alt, &float.alt);
         w.open("pic:cNvPicPr", &[]);
         w.empty("a:picLocks", &[("noChangeAspect", "1"), ("noChangeArrowheads", "1")]);
         w.close("pic:cNvPicPr");
@@ -839,14 +901,28 @@ impl Writer<'_> {
     /// A shape's or text box's `wps:wsp`, at `off` in its group (or 0, 0). In a group it carries
     /// its own `wps:cNvPr` with drawing id `id`.
     fn wsp(&mut self, w: &mut W, o: &InlineObject, id: Option<&str>, off: (f32, f32), rels: &mut PartRels, depth: usize) {
-        let InlineObject::Shape { kind, w: sw, h: sh, fill, stroke, stroke_width, story, effects, float, freeform } = o else { return };
+        let InlineObject::Shape { kind, w: sw, h: sh, fill, stroke, stroke_width, story, effects, float, freeform, extra } = o else { return };
         let geom = freeform.as_deref().filter(|_| *kind == ShapeKind::Freeform);
         w.open("wps:wsp", &[]);
         if let Some(id) = id {
             let name = shape_name(*kind, freeform.as_deref(), id);
-            w.empty("wps:cNvPr", &[("id", id), ("name", &name)]);
+            nv_props(w, "wps:cNvPr", id, &name, &float.alt.text, &float.alt);
         }
-        if *kind == ShapeKind::TextBox {
+        if kind.is_connector() {
+            // A connector's glued ends (ECMA-376 §20.1.2.2.8 `cNvCxnSpPr`).
+            let ends = [("a:stCxn", extra.start), ("a:endCxn", extra.end)];
+            if ends.iter().any(|(_, e)| e.is_some()) {
+                w.open("wps:cNvCnPr", &[]);
+                for (tag, e) in ends {
+                    if let Some(e) = e {
+                        w.empty(tag, &[("id", &e.id.to_string()), ("idx", &e.site.to_string())]);
+                    }
+                }
+                w.close("wps:cNvCnPr");
+            } else {
+                w.empty("wps:cNvCnPr", &[]);
+            }
+        } else if *kind == ShapeKind::TextBox {
             w.empty("wps:cNvSpPr", &[("txBox", "1")]);
         } else {
             w.empty("wps:cNvSpPr", &[]);
@@ -860,6 +936,9 @@ impl Writer<'_> {
             ShapeKind::Triangle => "triangle",
             ShapeKind::Diamond => "diamond",
             ShapeKind::Line => "line",
+            ShapeKind::StraightConnector => "straightConnector1",
+            ShapeKind::ElbowConnector => "bentConnector3",
+            ShapeKind::CurvedConnector => "curvedConnector3",
             ShapeKind::Arrow => "rightArrow",
             ShapeKind::Star => "star5",
             ShapeKind::Heart => "heart",
@@ -874,7 +953,7 @@ impl Writer<'_> {
         }
         let alpha = geom.map_or(1.0, |f| f.alpha);
         let ink = geom.is_some_and(|f| f.is_ink());
-        match fill.filter(|_| !ink) {
+        match fill.filter(|_| !ink && !kind.is_open()) {
             Some(c) => {
                 w.open("a:solidFill", &[]);
                 w.empty("a:srgbClr", &[("val", &c.hex())]);
@@ -899,6 +978,7 @@ impl Writer<'_> {
                 if ink {
                     w.empty("a:round", &[]);
                 }
+                arrow_ends(w, extra);
                 w.close("a:ln");
             }
             None => {
@@ -939,7 +1019,14 @@ impl Writer<'_> {
         if body.anchor != wordcraft_doc::props::VAlign::Top {
             attrs.push(("anchor", wordcraft_doc::props::anchor_ooxml(body.anchor)));
         }
-        w.empty("wps:bodyPr", &attrs);
+        match extra.warp.as_ref().and_then(|t| t.sanitized()) {
+            Some(warp) => {
+                w.open("wps:bodyPr", &attrs);
+                text_warp(w, &warp);
+                w.close("wps:bodyPr");
+            }
+            None => w.empty("wps:bodyPr", &attrs),
+        }
         w.close("wps:wsp");
     }
 
@@ -1023,7 +1110,7 @@ impl Writer<'_> {
             Wrap::TopAndBottom => w.empty("wp:wrapTopAndBottom", &[]),
             Wrap::BehindText | Wrap::InFrontOfText => w.empty("wp:wrapNone", &[]),
         }
-        w.empty("wp:docPr", &[("id", docpr), ("name", name), ("descr", alt)]);
+        nv_props(w, "wp:docPr", docpr, name, alt, &float.alt);
     }
 
     fn table(&mut self, w: &mut W, t: &Table, rels: &mut PartRels, depth: usize) {
@@ -1041,18 +1128,46 @@ impl Writer<'_> {
             w.empty("w:gridCol", &[("w:w", &twips(gw.max(0.0)))]);
         }
         w.close("w:tblGrid");
+        // Controls around rows and cells (repeating sections): opens and closes balanced
+        // whatever editing left, the ones still open closed at the end.
+        let mut open_rows = 0u32;
         for r in rows {
+            for c in &r.controls.open {
+                super::sdt::open(w, c);
+                open_rows += 1;
+            }
             w.open("w:tr", &[]);
             let chg = r.props.fmt_change.as_ref().map(|c| self.change_attrs(c.rev));
             trpr(w, &r.props, chg.as_ref());
+            let mut open_cells = 0u32;
             for c in &r.cells {
+                for ctl in &c.controls.open {
+                    super::sdt::open(w, ctl);
+                    open_cells += 1;
+                }
                 w.open("w:tc", &[]);
                 let chg = c.props.fmt_change.as_ref().map(|c| self.change_attrs(c.rev));
                 tcpr(w, &c.props, chg.as_ref());
                 self.blocks(w, &c.blocks, rels, false, depth + 1);
                 w.close("w:tc");
+                let n = c.controls.close.min(open_cells);
+                for _ in 0..n {
+                    super::sdt::close(w);
+                }
+                open_cells -= n;
+            }
+            for _ in 0..open_cells {
+                super::sdt::close(w);
             }
             w.close("w:tr");
+            let n = r.controls.close.min(open_rows);
+            for _ in 0..n {
+                super::sdt::close(w);
+            }
+            open_rows -= n;
+        }
+        for _ in 0..open_rows {
+            super::sdt::close(w);
         }
         w.close("w:tbl");
     }
@@ -1173,6 +1288,9 @@ fn sectpr_body(w: &mut W, s: &SectionProps) {
         if s.title_page {
             w.empty("w:titlePg", &[]);
         }
+        if s.text_direction.is_turned() {
+            w.val("w:textDirection", s.text_direction.ooxml());
+        }
         if s.rtl {
             w.empty("w:bidi", &[]);
         }
@@ -1191,11 +1309,15 @@ fn sectpr_body(w: &mut W, s: &SectionProps) {
     }
 }
 
-/// A shape's `cNvPr`/`docPr` name: ink is "Ink <pen> <id>", which reading looks for.
+/// A shape's `cNvPr`/`docPr` name: ink is "Ink <pen> <id>" (and "#<order>" when its drawing
+/// order is known), which reading looks for.
 fn shape_name(kind: ShapeKind, freeform: Option<&wordcraft_doc::freeform::Freeform>, id: &str) -> String {
-    match freeform.filter(|_| kind == ShapeKind::Freeform).and_then(|f| f.ink) {
-        Some(tool) => format!("Ink {} {id}", ink_name(tool)),
-        None => format!("Shape {id}"),
+    let f = freeform.filter(|_| kind == ShapeKind::Freeform);
+    match (f.and_then(|f| f.ink), f.and_then(|f| f.order)) {
+        // The drawing order rides along for Ink Replay: `Ink Pen 3 #12`.
+        (Some(tool), Some(n)) => format!("Ink {} {id} #{n}", ink_name(tool)),
+        (Some(tool), None) => format!("Ink {} {id}", ink_name(tool)),
+        (None, _) => format!("Shape {id}"),
     }
 }
 
@@ -1247,6 +1369,31 @@ fn cust_geom(w: &mut W, f: &wordcraft_doc::freeform::Freeform, sw: f32, sh: f32)
 }
 
 /// A shape's `a:effectLst` (ECMA-376 Part 1 §20.1.8.26), children in schema order.
+/// A line's arrowheads (`a:headEnd`, `a:tailEnd`, ECMA-376 §20.1.8.38 / §20.1.8.57).
+fn arrow_ends(w: &mut W, extra: &wordcraft_doc::connector::ShapeExtra) {
+    if extra.arrow_start {
+        w.empty("a:headEnd", &[("type", "triangle")]);
+    }
+    if extra.arrow_end {
+        w.empty("a:tailEnd", &[("type", "triangle")]);
+    }
+}
+
+/// A preset text warp (`a:prstTxWarp`, ECMA-376 §20.1.9.19) with its adjust values.
+fn text_warp(w: &mut W, warp: &wordcraft_doc::wordart::TextWarp) {
+    w.open("a:prstTxWarp", &[("prst", &warp.preset)]);
+    if warp.adj.is_empty() {
+        w.empty("a:avLst", &[]);
+    } else {
+        w.open("a:avLst", &[]);
+        for (name, v) in &warp.adj {
+            w.empty("a:gd", &[("name", name), ("fmla", &format!("val {v}"))]);
+        }
+        w.close("a:avLst");
+    }
+    w.close("a:prstTxWarp");
+}
+
 fn effect_list(w: &mut W, effects: &ShapeEffects) {
     let fx = effects.sanitized();
     if fx.is_empty() {
@@ -1362,6 +1509,31 @@ fn toc_span(bl: &Blocks) -> Option<(usize, usize)> {
     (entries > 0).then_some((start, start + entries))
 }
 
+/// A drawing's `wp:docPr` (or a group member's `pic:cNvPr`/`wps:cNvPr`, ECMA-376
+/// `CT_NonVisualDrawingProps`) with its alt text `descr`, its title, and the decorative mark as
+/// the `adec:decorative` extension ([MS-ODRAWXML]). A description that is only the title (read
+/// from a file with no description) is not written twice.
+pub(super) fn nv_props(w: &mut W, tag: &str, id: &str, name: &str, descr: &str, alt: &AltText) {
+    let mut attrs = vec![("id", id), ("name", name)];
+    if descr != alt.title || descr.is_empty() {
+        attrs.push(("descr", descr));
+    }
+    if !alt.title.is_empty() {
+        attrs.push(("title", alt.title.as_str()));
+    }
+    if !alt.decorative {
+        w.empty(tag, &attrs);
+        return;
+    }
+    w.open(tag, &attrs);
+    w.open("a:extLst", &[]);
+    w.open("a:ext", &[("uri", crate::xml::DECORATIVE_EXT)]);
+    w.empty("adec:decorative", &[("xmlns:adec", crate::xml::DECORATIVE_NS), ("val", "1")]);
+    w.close("a:ext");
+    w.close("a:extLst");
+    w.close(tag);
+}
+
 /// A DrawingML `a:solidFill` in `c`, or `a:noFill`.
 fn solid_fill(w: &mut W, c: Option<wordcraft_doc::props::Rgb>) {
     match c {
diff --git a/crates/docx/src/write/wordart.rs b/crates/docx/src/write/wordart.rs
new file mode 100644
index 0000000000..ca0fee0742
--- /dev/null
+++ b/crates/docx/src/write/wordart.rs
@@ -0,0 +1,121 @@
+//! WordArt text effects as `w14:` run properties ([MS-DOCX] §2.6.1), in the schema's order:
+//! glow, shadow, reflection, text outline, text fill. Lengths are EMUs, angles 60000ths of a
+//! degree, percentages 1000ths of a percent.
+
+use wordcraft_doc::props::Rgb;
+use wordcraft_doc::wordart::{TextEffects, TextFill};
+
+use crate::units::{emu, n};
+use crate::xml::W;
+
+fn pct(v: f32) -> String {
+    n((wordcraft_geom::finite(v).clamp(0.0, 100.0) * 1000.0).round() as i64)
+}
+
+fn ang(deg: f32) -> String {
+    n((wordcraft_geom::finite(deg).rem_euclid(360.0) * 60_000.0).round().clamp(0.0, 21_599_999.0) as i64)
+}
+
+fn len(pt: f32) -> String {
+    emu(wordcraft_geom::finite(pt).clamp(0.0, 2000.0))
+}
+
+/// `w14:srgbClr` with its transparency (`w14:alpha` is the transparency, not the opacity).
+fn color(w: &mut W, c: Rgb, transparency: f32) {
+    if transparency > 0.0 {
+        w.open("w14:srgbClr", &[("w14:val", &c.hex())]);
+        w.empty("w14:alpha", &[("w14:val", &pct(transparency))]);
+        w.close("w14:srgbClr");
+    } else {
+        w.empty("w14:srgbClr", &[("w14:val", &c.hex())]);
+    }
+}
+
+fn fill(w: &mut W, f: &TextFill) {
+    match f {
+        TextFill::None => w.empty("w14:noFill", &[]),
+        TextFill::Solid { color: c, transparency } => {
+            w.open("w14:solidFill", &[]);
+            color(w, *c, *transparency);
+            w.close("w14:solidFill");
+        }
+        TextFill::Gradient { stops, angle } => {
+            w.open("w14:gradFill", &[]);
+            w.open("w14:gsLst", &[]);
+            for s in stops {
+                w.open("w14:gs", &[("w14:pos", &pct(s.pos))]);
+                color(w, s.color, s.transparency);
+                w.close("w14:gs");
+            }
+            w.close("w14:gsLst");
+            w.empty("w14:lin", &[("w14:ang", &ang(*angle)), ("w14:scaled", "0")]);
+            w.close("w14:gradFill");
+        }
+    }
+}
+
+/// The effects of `fx` (sanitized first).
+pub fn rpr_effects(w: &mut W, fx: &TextEffects) {
+    let fx = fx.sanitized();
+    if let Some(g) = fx.glow {
+        w.open("w14:glow", &[("w14:rad", &len(g.size))]);
+        color(w, g.color, g.transparency);
+        w.close("w14:glow");
+    }
+    if let Some(s) = fx.shadow {
+        w.open(
+            "w14:shadow",
+            &[
+                ("w14:blurRad", &len(s.blur)),
+                ("w14:dist", &len(s.distance)),
+                ("w14:dir", &ang(s.angle)),
+                ("w14:sx", "100000"),
+                ("w14:sy", "100000"),
+                ("w14:kx", "0"),
+                ("w14:ky", "0"),
+                ("w14:algn", "ctr"),
+            ],
+        );
+        color(w, s.color, s.transparency);
+        w.close("w14:shadow");
+    }
+    if let Some(r) = fx.reflection {
+        w.empty(
+            "w14:reflection",
+            &[
+                ("w14:blurRad", &len(r.blur)),
+                ("w14:stA", &pct(100.0 - r.transparency)),
+                ("w14:stPos", "0"),
+                ("w14:endA", "0"),
+                ("w14:endPos", &pct(r.size)),
+                ("w14:dist", &len(r.distance)),
+                ("w14:dir", "5400000"),
+                ("w14:fadeDir", "5400000"),
+                ("w14:sx", "100000"),
+                ("w14:sy", "-100000"),
+                ("w14:kx", "0"),
+                ("w14:ky", "0"),
+                ("w14:algn", "bl"),
+            ],
+        );
+    }
+    if let Some(o) = fx.outline {
+        w.open("w14:textOutline", &[("w14:w", &len(o.width)), ("w14:cap", "flat"), ("w14:cmpd", "sng"), ("w14:algn", "ctr")]);
+        match o.color {
+            Some(c) => {
+                w.open("w14:solidFill", &[]);
+                color(w, c, o.transparency);
+                w.close("w14:solidFill");
+            }
+            None => w.empty("w14:noFill", &[]),
+        }
+        w.empty("w14:prstDash", &[("w14:val", "solid")]);
+        w.empty("w14:round", &[]);
+        w.close("w14:textOutline");
+    }
+    if let Some(f) = &fx.fill {
+        w.open("w14:textFill", &[]);
+        fill(w, f);
+        w.close("w14:textFill");
+    }
+}
diff --git a/crates/docx/src/xml.rs b/crates/docx/src/xml.rs
index 5b7e70439b..925122c706 100644
--- a/crates/docx/src/xml.rs
+++ b/crates/docx/src/xml.rs
@@ -39,8 +39,14 @@ pub const NAMESPACES: &[(&str, &str)] = &[
     ("w10", "urn:schemas-microsoft-com:office:word"),
 ];
 
+/// The `a:ext` URI under which a drawing is marked decorative ([MS-ODRAWXML]), and the
+/// namespace of its `adec:decorative` element.
+pub const DECORATIVE_EXT: &str = "{C183D7F6-B498-43B3-948B-1728B52AA6E4}";
+pub const DECORATIVE_NS: &str = "http://schemas.microsoft.com/office/drawing/2017/decorative";
+
 /// Namespaces that only appear in non-body parts.
 const OTHER_NAMESPACES: &[(&str, &str)] = &[
+    ("b", "http://schemas.openxmlformats.org/officeDocument/2006/bibliography"),
     ("rel", "http://schemas.openxmlformats.org/package/2006/relationships"),
     ("ct", "http://schemas.openxmlformats.org/package/2006/content-types"),
     ("cp", "http://schemas.openxmlformats.org/package/2006/metadata/core-properties"),
@@ -63,7 +69,10 @@ const STRICT: &[(&str, &str)] = &[
     ("m", "http://purl.oclc.org/ooxml/officeDocument/math"),
 ];
 
-fn prefix_for(uri: &[u8]) -> &'static str {
+fn prefix_for(uri: &[u8], extra: &[(&'static str, &str)]) -> &'static str {
+    if let Some((p, _)) = extra.iter().find(|(_, u)| u.as_bytes() == uri) {
+        return p;
+    }
     for (p, u) in NAMESPACES.iter().chain(OTHER_NAMESPACES).chain(STRICT) {
         if u.as_bytes() == uri {
             return p;
@@ -205,10 +214,9 @@ impl El {
     }
 }
 
-/// Parse XML bytes into the root element.
 /// UTF-16 LE/BE text with a byte-order mark as UTF-8 (`None` without one). Lossy: an unpaired
 /// surrogate becomes U+FFFD and a trailing odd byte is dropped. The result is at most 1.5× the input.
-fn utf16_to_utf8(bytes: &[u8]) -> Option<String> {
+pub(crate) fn utf16_to_utf8(bytes: &[u8]) -> Option<String> {
     let (rest, le) = match bytes.get(..2) {
         Some([0xFF, 0xFE]) => (bytes.get(2..)?, true),
         Some([0xFE, 0xFF]) => (bytes.get(2..)?, false),
@@ -218,7 +226,14 @@ fn utf16_to_utf8(bytes: &[u8]) -> Option<String> {
     Some(char::decode_utf16(units).map(|c| c.unwrap_or(char::REPLACEMENT_CHARACTER)).collect())
 }
 
+/// Parse XML bytes into the root element.
 pub fn parse(bytes: &[u8]) -> Result<El, DocxError> {
+    parse_ns(bytes, &[])
+}
+
+/// [`parse`] with `extra` namespaces (prefix, URI) mapped to canonical prefixes first, so a
+/// related vocabulary (WordprocessingML 2003) reads with the prefixes the reader knows.
+pub fn parse_ns(bytes: &[u8], extra: &[(&'static str, &str)]) -> Result<El, DocxError> {
     // UTF-16 (with a BOM) is transcoded to UTF-8; a UTF-8 BOM is stripped.
     let transcoded = utf16_to_utf8(bytes);
     let bytes = match &transcoded {
@@ -241,7 +256,7 @@ pub fn parse(bytes: &[u8]) -> Result<El, DocxError> {
         buf.clear();
         let (res, ev) = r.read_resolved_event_into(&mut buf).map_err(|e| DocxError::Xml(e.to_string()))?;
         let el_prefix = match &res {
-            ResolveResult::Bound(ns) => Some(prefix_for(ns.as_ref())),
+            ResolveResult::Bound(ns) => Some(prefix_for(ns.as_ref(), extra)),
             _ => None,
         };
         match ev {
@@ -266,7 +281,7 @@ pub fn parse(bytes: &[u8]) -> Result<El, DocxError> {
                     let (ares, alocal) = r.resolver_mut().resolve_attribute(key);
                     let alocal = String::from_utf8_lossy(alocal.as_ref()).into_owned();
                     let aname = match ares {
-                        ResolveResult::Bound(ns) => format!("{}:{alocal}", prefix_for(ns.as_ref())),
+                        ResolveResult::Bound(ns) => format!("{}:{alocal}", prefix_for(ns.as_ref(), extra)),
                         _ => alocal,
                     };
                     let val = match a.normalized_value(XmlVersion::Explicit1_0) {
diff --git a/crates/docx/tests/char_units.rs b/crates/docx/tests/char_units.rs
new file mode 100644
index 0000000000..3aa09e3625
--- /dev/null
+++ b/crates/docx/tests/char_units.rs
@@ -0,0 +1,55 @@
+//! Indents in character units (#534), common in Chinese documents: ECMA-376 Part 1 §17.3.1.12
+//! `w:ind` `w:firstLineChars`, `w:hangingChars`, `w:leftChars` and `w:rightChars`, in hundredths
+//! of a character. Fixtures are hand-written.
+
+use std::io::{Read, Write};
+
+use wordcraft_doc::Document;
+use wordcraft_doc::props::ParaProps;
+
+fn zip(entries: &[(&str, &[u8])]) -> Vec<u8> {
+    let mut zw = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    for (name, bytes) in entries {
+        zw.start_file(*name, zip::write::SimpleFileOptions::default()).unwrap();
+        zw.write_all(bytes).unwrap();
+    }
+    zw.finish().unwrap().into_inner()
+}
+
+/// A package whose body is `body`.
+fn docx(body: &str) -> Vec<u8> {
+    let root = r#"<?xml version="1.0" encoding="UTF-8"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>"#;
+    let doc = format!(
+        r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>{body}</w:body></w:document>"#
+    );
+    zip(&[("_rels/.rels", root.as_bytes()), ("word/document.xml", doc.as_bytes())])
+}
+
+fn props(d: &Document) -> Vec<ParaProps> {
+    d.body.iter().filter_map(|b| b.as_para()).map(|p| p.props.clone()).collect()
+}
+
+#[test]
+fn character_indents_read_and_round_trip() {
+    let body = r#"<w:p><w:pPr><w:ind w:firstLineChars="200" w:firstLine="420"/></w:pPr><w:r><w:t>一</w:t></w:r></w:p>
+        <w:p><w:pPr><w:ind w:leftChars="150" w:left="315" w:rightChars="50" w:right="105" w:hangingChars="100" w:hanging="210"/></w:pPr><w:r><w:t>二</w:t></w:r></w:p>
+        <w:p><w:pPr><w:ind w:firstLineChars="0" w:firstLine="240"/></w:pPr><w:r><w:t>三</w:t></w:r></w:p>
+        <w:p><w:pPr><w:ind w:firstLineChars="99999999" w:leftChars="junk"/></w:pPr><w:r><w:t>四</w:t></w:r></w:p>"#;
+    let d = wordcraft_docx::read(&docx(body)).unwrap();
+    let p = props(&d);
+    assert_eq!((p[0].indent_first_chars, p[0].indent_first), (Some(2.0), Some(21.0)));
+    assert_eq!((p[1].indent_left_chars, p[1].indent_right_chars, p[1].indent_first_chars), (Some(1.5), Some(0.5), Some(-1.0)));
+    // Zero cancels an inherited value; the points apply.
+    assert_eq!((p[2].indent_first_chars, p[2].indent_first), (Some(0.0), Some(12.0)));
+    // Hostile values are clamped or dropped.
+    assert_eq!((p[3].indent_first_chars, p[3].indent_left_chars), (Some(1584.0), None));
+
+    let mut z = zip::ZipArchive::new(std::io::Cursor::new(wordcraft_docx::write(&d).unwrap())).unwrap();
+    let mut xml = String::new();
+    z.by_name("word/document.xml").unwrap().read_to_string(&mut xml).unwrap();
+    for attr in [r#"w:firstLineChars="200""#, r#"w:leftChars="150""#, r#"w:rightChars="50""#, r#"w:hangingChars="100""#, r#"w:firstLineChars="0""#] {
+        assert!(xml.contains(attr), "{attr} missing: {xml}");
+    }
+    let again = props(&wordcraft_docx::read(&docx(&xml[xml.find("<w:body>").unwrap() + 8..xml.find("</w:body>").unwrap()])).unwrap());
+    assert_eq!(again[..3], p[..3]);
+}
diff --git a/crates/docx/tests/content_controls.rs b/crates/docx/tests/content_controls.rs
new file mode 100644
index 0000000000..e37de7392e
--- /dev/null
+++ b/crates/docx/tests/content_controls.rs
@@ -0,0 +1,230 @@
+//! Content controls (`w:sdt`) keep their properties, levels and nesting through a round trip.
+//! All markup here is synthetic, written from ECMA-376 §17.5.2 and the [MS-DOCX] `w14`/`w15`
+//! extensions.
+
+use std::io::Write;
+
+use wordcraft_doc::control::{ControlKind, ControlLock, ListItem};
+use wordcraft_doc::{Block, ContentControl, Document, StoryRef};
+use wordcraft_docx::{read, write};
+
+const NS: &str = r#"xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main" xmlns:w14="http://schemas.microsoft.com/office/word/2010/wordml" xmlns:w15="http://schemas.microsoft.com/office/word/2012/wordml""#;
+const ROOT_RELS: &str = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>"#;
+
+fn package(body: &str) -> Vec<u8> {
+    let doc = format!(r#"<w:document {NS}><w:body>{body}</w:body></w:document>"#);
+    let mut zw = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    for (name, bytes) in [("_rels/.rels", ROOT_RELS.as_bytes()), ("word/document.xml", doc.as_bytes())] {
+        zw.start_file(name, zip::write::SimpleFileOptions::default()).unwrap();
+        zw.write_all(bytes).unwrap();
+    }
+    zw.finish().unwrap().into_inner()
+}
+
+fn t(s: &str) -> String {
+    format!(r#"<w:r><w:t xml:space="preserve">{s}</w:t></w:r>"#)
+}
+fn p(inner: &str) -> String {
+    format!("<w:p>{inner}</w:p>")
+}
+fn sdt(pr: &str, content: &str) -> String {
+    format!("<w:sdt><w:sdtPr>{pr}</w:sdtPr><w:sdtContent>{content}</w:sdtContent></w:sdt>")
+}
+fn cell(text: &str) -> String {
+    format!("<w:tc>{}</w:tc>", p(&t(text)))
+}
+
+/// Every kind of control, at every level, with nesting.
+fn form() -> Vec<u8> {
+    let block = sdt(
+        r#"<w:rPr><w:b/></w:rPr><w:alias w:val="Intro"/><w:tag w:val="intro"/><w:id w:val="-1201"/><w:lock w:val="sdtLocked"/><w:placeholder><w:docPart w:val="DefaultPlaceholder_1"/></w:placeholder><w:showingPlcHdr/><w15:appearance w15:val="tags"/>"#,
+        &format!("{}{}", p(&t("Write the introduction.")), p(&t("Second paragraph"))),
+    );
+    let inline = p(&format!(
+        "{}{}{}{}{}{}",
+        t("Name: "),
+        sdt(r#"<w:alias w:val="Name"/><w:id w:val="7"/><w:text w:multiLine="1"/>"#, &t("Ada")),
+        t(" Agree: "),
+        sdt(
+            r#"<w:id w:val="8"/><w14:checkbox><w14:checked w14:val="1"/><w14:checkedState w14:val="2612" w14:font="Symbola"/><w14:uncheckedState w14:val="2610" w14:font="Symbola"/></w14:checkbox>"#,
+            &t("\u{2612}")
+        ),
+        sdt(
+            r#"<w:id w:val="9"/><w:lock w:val="contentLocked"/><w:dropDownList w:lastValue="b"><w:listItem w:displayText="Alpha" w:value="a"/><w:listItem w:displayText="Beta" w:value="b"/></w:dropDownList>"#,
+            &t("Beta")
+        ),
+        sdt(
+            r#"<w:id w:val="10"/><w:dataBinding w:xpath="/root/when" w:storeItemID="{00000000-0000-0000-0000-000000000001}"/><w:date w:fullDate="2026-10-11T00:00:00Z"><w:dateFormat w:val="d.M.yyyy"/><w:lid w:val="de-DE"/><w:storeMappedDataAs w:val="dateTime"/><w:calendar w:val="gregorian"/></w:date>"#,
+            &t("11.10.2026")
+        ),
+    ));
+    // A combo box holding a nested rich text control.
+    let nested = p(&sdt(
+        r#"<w:id w:val="11"/><w:comboBox><w:listItem w:displayText="One" w:value="1"/></w:comboBox>"#,
+        &format!("{}{}", t("Pick "), sdt(r#"<w:id w:val="12"/><w:richText/>"#, &t("inner"))),
+    ));
+    let gallery = sdt(r#"<w:id w:val="13"/><w:docPartObj><w:docPartGallery w:val="Cover Pages"/><w:docPartUnique/></w:docPartObj>"#, &p(&t("Cover")));
+    // A repeating section around table rows, each row an item; a control around one cell; a
+    // picture control holding nothing but a paragraph mark's worth of text.
+    let row = |a: &str, b: &str| format!("<w:tr>{}{}</w:tr>", cell(a), cell(b));
+    let table = format!(
+        "<w:tbl><w:tblGrid><w:gridCol w:w=\"2000\"/><w:gridCol w:w=\"2000\"/></w:tblGrid>{}</w:tbl>",
+        sdt(
+            r#"<w:id w:val="20"/><w15:repeatingSection><w15:sectionTitle w:val="Items"/></w15:repeatingSection>"#,
+            &format!(
+                "{}{}",
+                sdt(r#"<w:id w:val="21"/><w15:repeatingSectionItem/>"#, &row("x", "y")),
+                sdt(
+                    r#"<w:id w:val="22"/><w15:repeatingSectionItem/>"#,
+                    &format!("<w:tr>{}{}</w:tr>", cell("z"), sdt(r#"<w:id w:val="23"/><w:picture/>"#, &cell("pic")))
+                )
+            )
+        )
+    );
+    // A block control whose content is a table.
+    let around_table = sdt(
+        r#"<w:id w:val="30"/><w:tag w:val="grid"/>"#,
+        &format!("<w:tbl><w:tblGrid><w:gridCol w:w=\"2000\"/></w:tblGrid>{}</w:tbl>", format_args!("<w:tr>{}</w:tr>", cell("t"))),
+    );
+    package(&format!("{block}{inline}{nested}{gallery}{table}{around_table}{}", p(&t("End"))))
+}
+
+fn document_xml(docx: &[u8]) -> String {
+    let mut z = zip::ZipArchive::new(std::io::Cursor::new(docx)).unwrap();
+    let mut s = String::new();
+    std::io::Read::read_to_string(&mut z.by_name("word/document.xml").unwrap(), &mut s).unwrap();
+    s
+}
+
+fn controls(d: &Document) -> Vec<ContentControl> {
+    let mut out = Vec::new();
+    wordcraft_doc::control::walk_controls(&d.body, &mut |c| out.push(c.clone()));
+    out
+}
+
+fn by_id(d: &Document, id: i64) -> ContentControl {
+    controls(d).into_iter().find(|c| c.id == Some(id)).unwrap_or_else(|| panic!("control {id}"))
+}
+
+#[test]
+fn every_kind_reads_with_its_properties() {
+    let d = read(&form()).unwrap();
+    let intro = controls(&d).into_iter().find(|c| c.title == "Intro").unwrap();
+    assert!(intro.block && intro.showing_placeholder);
+    assert_eq!((intro.tag.as_str(), intro.id, intro.lock), ("intro", Some(-1201), ControlLock::SdtLocked));
+    assert_eq!(intro.placeholder, "DefaultPlaceholder_1");
+    assert_eq!(intro.placeholder_text, "Write the introduction.");
+    assert!(intro.rpr_xml.contains("w:b"));
+    assert_eq!(intro.extra, vec![r#"<w15:appearance w15:val="tags"/>"#.to_string()]);
+    let ranges = d.control_ranges(StoryRef::Body);
+    let r = ranges.iter().find(|r| r.control.title == "Intro").unwrap();
+    assert_eq!(d.control_text(r), "Write the introduction.\nSecond paragraph");
+
+    assert_eq!(by_id(&d, 7).kind, ControlKind::Text { multi_line: true });
+    assert!(!by_id(&d, 7).block);
+    assert!(
+        matches!(by_id(&d, 8).kind, ControlKind::CheckBox { checked: true, checked_char: '\u{2612}', ref checked_font, .. } if checked_font == "Symbola")
+    );
+    let dd = by_id(&d, 9);
+    assert_eq!(dd.lock, ControlLock::ContentLocked);
+    assert_eq!(
+        dd.kind,
+        ControlKind::DropDown {
+            items: vec![ListItem { display: "Alpha".into(), value: "a".into() }, ListItem { display: "Beta".into(), value: "b".into() }],
+            last_value: "b".into()
+        }
+    );
+    assert!(
+        matches!(by_id(&d, 10).kind, ControlKind::Date { ref full_date, ref format, .. } if full_date == "2026-10-11T00:00:00Z" && format == "d.M.yyyy")
+    );
+    assert_eq!(by_id(&d, 10).extra.len(), 1, "data binding kept");
+    assert_eq!(by_id(&d, 12).kind, ControlKind::RichText);
+    assert!(matches!(by_id(&d, 13).kind, ControlKind::Gallery { list: false, ref gallery, unique: true, .. } if gallery == "Cover Pages"));
+    assert!(matches!(by_id(&d, 20).kind, ControlKind::RepeatingSection { ref title, .. } if title == "Items"));
+    assert_eq!(by_id(&d, 21).kind, ControlKind::RepeatingSectionItem);
+    assert_eq!(by_id(&d, 23).kind, ControlKind::Picture);
+    // Row-level controls sit on the rows, the cell-level one on its cell, the table's on the table.
+    let tables: Vec<_> = d.body.iter().filter_map(|b| b.as_table()).collect();
+    assert_eq!(tables.len(), 2);
+    let rows = &tables[0].rows;
+    assert_eq!(rows[0].controls.open.iter().map(|c| c.id).collect::<Vec<_>>(), vec![Some(20), Some(21)]);
+    assert_eq!((rows[0].controls.close, rows[1].controls.close), (1, 2));
+    assert_eq!(rows[1].cells[1].controls.open[0].id, Some(23));
+    assert_eq!(tables[1].controls.open[0].tag, "grid");
+    assert_eq!(tables[1].controls.close, 1);
+    // The text reads as before.
+    assert!(d.plain_text(StoryRef::Body).contains("Name: Ada Agree: \u{2612}Beta11.10.2026"));
+}
+
+#[test]
+fn controls_round_trip() {
+    let d = read(&form()).unwrap();
+    let bytes = write(&d).unwrap();
+    let back = read(&bytes).unwrap();
+    assert_eq!(controls(&back), controls(&d));
+    assert_eq!(back.plain_text(StoryRef::Body), d.plain_text(StoryRef::Body));
+    assert_eq!(back.body.len(), d.body.len());
+    let names: Vec<_> = back.control_ranges(StoryRef::Body).iter().map(|r| (r.control.id, r.start.path.clone(), r.end.path.clone())).collect();
+    let before: Vec<_> = d.control_ranges(StoryRef::Body).iter().map(|r| (r.control.id, r.start.path.clone(), r.end.path.clone())).collect();
+    assert_eq!(names, before);
+    // Written in schema order, with the extension elements the file had.
+    let xml = document_xml(&bytes);
+    assert!(xml.contains(
+        r#"<w:sdtPr><w:rPr><w:b/></w:rPr><w:alias w:val="Intro"/><w:tag w:val="intro"/><w:id w:val="-1201"/><w:lock w:val="sdtLocked"/><w:placeholder><w:docPart w:val="DefaultPlaceholder_1"/></w:placeholder><w:showingPlcHdr/><w15:appearance w15:val="tags"/></w:sdtPr>"#
+    ));
+    assert!(xml.contains(r#"<w14:checkbox><w14:checked w14:val="1"/><w14:checkedState w14:val="2612" w14:font="Symbola"/>"#));
+    // The block control is around the paragraphs, the inline ones inside theirs.
+    assert!(xml.contains("<w:sdtContent><w:p>"));
+    assert!(xml.contains(r#"<w:dataBinding w:xpath="/root/when" w:storeItemID="{00000000-0000-0000-0000-000000000001}"/><w:date"#));
+}
+
+#[test]
+fn edited_documents_still_write_whole_controls() {
+    let mut d = read(&form()).unwrap();
+    // Merge the block control's first paragraph into the one before nothing: delete across the
+    // start of the inline name control and the end of the block control.
+    let ranges = d.control_ranges(StoryRef::Body);
+    let name = ranges.iter().find(|r| r.control.id == Some(7)).unwrap().clone();
+    let intro = ranges.iter().find(|r| r.control.title == "Intro").unwrap().clone();
+    let from = wordcraft_doc::Pos { off: 3, ..intro.end.clone() };
+    let to = wordcraft_doc::Pos { off: name.start.off + 4, ..name.start.clone() };
+    d.delete_range(&from, &to).unwrap();
+    // Both controls are still there, emptied where the deletion went through them.
+    let after = d.control_ranges(StoryRef::Body);
+    assert!(after.iter().any(|r| r.control.id == Some(7)));
+    assert!(after.iter().any(|r| r.control.title == "Intro"));
+    let back = read(&write(&d).unwrap()).unwrap();
+    assert_eq!(controls(&back).len(), controls(&d).len());
+    // An orphan marker (a table carrying an open that lost its table) is dropped on save.
+    if let Some(Block::Table(t)) = d.body.iter_mut().rev().find(|b| b.as_table().is_some()).map(std::sync::Arc::make_mut) {
+        t.controls.close = 0;
+    }
+    assert!(d.has_unbalanced_controls());
+    let back = read(&write(&d).unwrap()).unwrap();
+    assert!(!back.has_unbalanced_controls());
+}
+
+#[test]
+fn deeply_nested_controls_are_bounded() {
+    let mut s = t("core");
+    for i in 0..400 {
+        s = sdt(&format!(r#"<w:id w:val="{i}"/>"#), &s);
+    }
+    let mut b = p(&t("x"));
+    for i in 0..400 {
+        b = sdt(&format!(r#"<w:id w:val="{i}"/>"#), &b);
+    }
+    for body in [p(&s), b] {
+        // Too deep for the parser: an error or a document, never a panic or a hang.
+        if let Ok(d) = read(&package(&body)) {
+            let _ = write(&d).unwrap();
+        }
+    }
+    let mut s = t("core");
+    for i in 0..60 {
+        s = sdt(&format!(r#"<w:id w:val="{i}"/>"#), &s);
+    }
+    let d = read(&package(&p(&s))).unwrap();
+    let back = read(&write(&d).unwrap()).unwrap();
+    assert_eq!(controls(&back).len(), 60);
+}
diff --git a/crates/docx/tests/custom_xml.rs b/crates/docx/tests/custom_xml.rs
new file mode 100644
index 0000000000..53c1f0c6e2
--- /dev/null
+++ b/crates/docx/tests/custom_xml.rs
@@ -0,0 +1,179 @@
+//! Original synthetic custom XML stores, written from the public OOXML package contract.
+use std::collections::BTreeMap;
+use std::io::{Cursor, Read, Write};
+use wordcraft_doc::{Path, StoryRef};
+
+const REL_NS: &str = "http://schemas.openxmlformats.org/package/2006/relationships";
+const RT: &str = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/";
+const DATA: &str =
+    "<?xml version=\"1.0\"?><c:customer xmlns:c=\"urn:original:customer\"><c:name>Atlas Studios</c:name><c:ref>CASE-17</c:ref></c:customer>";
+const PROPS: &str = r#"<ds:datastoreItem xmlns:ds="http://schemas.openxmlformats.org/officeDocument/2006/customXml" ds:itemID="{22222222-2222-2222-2222-222222222222}"><ds:schemaRefs><ds:schemaRef ds:uri="urn:original:customer"/></ds:schemaRefs></ds:datastoreItem>"#;
+
+fn rels(rows: &[(&str, &str, &str, bool)]) -> String {
+    let mut out = format!(r#"<Relationships xmlns="{REL_NS}">"#);
+    for (id, kind, target, external) in rows {
+        let mode = if *external { r#" TargetMode="External""# } else { "" };
+        out.push_str(&format!(r#"<Relationship Id="{id}" Type="{RT}{kind}" Target="{target}"{mode}/>"#));
+    }
+    out + "</Relationships>"
+}
+
+fn fixture() -> BTreeMap<String, Vec<u8>> {
+    let doc = r#"<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body><w:p><w:r><w:t>Independent edit.</w:t></w:r></w:p><w:p><w:sdt><w:sdtPr><w:id w:val="42"/><w:dataBinding w:xpath="/c:customer/c:name" w:prefixMappings="xmlns:c='urn:original:customer'" w:storeItemID="{22222222-2222-2222-2222-222222222222}"/><w:text/></w:sdtPr><w:sdtContent><w:r><w:t>Atlas Studios</w:t></w:r></w:sdtContent></w:sdt></w:p></w:body></w:document>"#;
+    let types = r#"<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="xml" ContentType="application/xml"/><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Override PartName="/word/document.xml" ContentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml"/><Override PartName="/customXml/itemProps1.xml" ContentType="application/vnd.openxmlformats-officedocument.customXmlProperties+xml"/></Types>"#;
+    [
+        ("[Content_Types].xml", types.to_string()),
+        ("_rels/.rels", rels(&[("office", "officeDocument", "word/document.xml", false)])),
+        ("word/document.xml", doc.to_string()),
+        ("word/_rels/document.xml.rels", rels(&[("data", "customXml", "../customXml/item1.xml", false)])),
+        ("customXml/item1.xml", DATA.to_string()),
+        ("customXml/itemProps1.xml", PROPS.to_string()),
+        ("customXml/_rels/item1.xml.rels", rels(&[("properties", "customXmlProps", "itemProps1.xml", false)])),
+    ]
+    .into_iter()
+    .map(|(p, s)| (p.into(), s.into_bytes()))
+    .collect()
+}
+
+fn zip(parts: &BTreeMap<String, Vec<u8>>) -> Vec<u8> {
+    let mut z = zip::ZipWriter::new(Cursor::new(Vec::new()));
+    for (name, bytes) in parts {
+        z.start_file(name, zip::write::SimpleFileOptions::default()).unwrap();
+        z.write_all(bytes).unwrap();
+    }
+    z.finish().unwrap().into_inner()
+}
+
+fn unzip(bytes: &[u8]) -> BTreeMap<String, Vec<u8>> {
+    let mut z = zip::ZipArchive::new(Cursor::new(bytes)).unwrap();
+    let mut parts = BTreeMap::new();
+    for i in 0..z.len() {
+        let mut f = z.by_index(i).unwrap();
+        let name = f.name().to_string();
+        let mut bytes = Vec::new();
+        f.read_to_end(&mut bytes).unwrap();
+        assert!(parts.insert(name, bytes).is_none(), "duplicate ZIP entry");
+    }
+    parts
+}
+
+fn text(parts: &BTreeMap<String, Vec<u8>>, name: &str) -> String {
+    String::from_utf8(parts[name].clone()).unwrap()
+}
+
+fn edited_cycles(input: &BTreeMap<String, Vec<u8>>, check: impl Fn(&BTreeMap<String, Vec<u8>>)) {
+    let mut doc = wordcraft_docx::read(&zip(input)).unwrap();
+    for _ in 0..2 {
+        doc.para_mut(StoryRef::Body, &Path::top(0)).unwrap().insert_text(0, "Unrelated edit. ", &Default::default()).unwrap();
+        let bytes = wordcraft_docx::write(&doc).unwrap();
+        check(&unzip(&bytes));
+        doc = wordcraft_docx::read(&bytes).unwrap();
+    }
+}
+
+#[test]
+fn bound_store_bytes_properties_and_relationships_survive_two_edited_saves() {
+    edited_cycles(&fixture(), |p| {
+        let document = text(p, "word/document.xml");
+        assert!(document.contains("<w:dataBinding"), "the control keeps its store binding");
+        assert!(document.contains(r#"w:storeItemID="{22222222-2222-2222-2222-222222222222}""#));
+        assert!(document.contains(r#"w:xpath="/c:customer/c:name""#));
+        assert_eq!(p.get("customXml/item1.xml").map(Vec::as_slice), Some(DATA.as_bytes()));
+        assert_eq!(p.get("customXml/itemProps1.xml").map(Vec::as_slice), Some(PROPS.as_bytes()));
+        assert!(text(p, "word/_rels/document.xml.rels").contains(r#"Target="../customXml/item1.xml""#));
+        assert!(text(p, "customXml/_rels/item1.xml.rels").contains(r#"Id="properties""#));
+        assert!(text(p, "customXml/_rels/item1.xml.rels").contains(r#"Target="itemProps1.xml""#));
+        assert!(text(p, "[Content_Types].xml").contains("application/vnd.openxmlformats-officedocument.customXmlProperties+xml"));
+    });
+}
+
+#[test]
+fn package_and_document_roots_share_parts_and_keep_multiple_stores() {
+    let mut p = fixture();
+    p.insert(
+        "_rels/.rels".into(),
+        rels(&[("office", "officeDocument", "word/document.xml", false), ("data", "customXml", "customXml/item1.xml", false)]).into_bytes(),
+    );
+    p.insert(
+        "word/_rels/document.xml.rels".into(),
+        rels(&[("one", "customXml", "../customXml/item1.xml", false), ("two", "customXml", "../customXml/other.xml", false)]).into_bytes(),
+    );
+    p.insert("customXml/other.xml".into(), b"<other>Independent store</other>".to_vec());
+    p.insert("customXml/_rels/other.xml.rels".into(), rels(&[("shared", "customXmlProps", "itemProps1.xml", false)]).into_bytes());
+    // A cycle must not cause repeated parts, and an external schema stays external.
+    p.insert(
+        "customXml/_rels/itemProps1.xml.rels".into(),
+        rels(&[("cycle", "customXml", "item1.xml", false), ("schema", "schema", "https://example.invalid/schema", true)]).into_bytes(),
+    );
+    edited_cycles(&p, |out| {
+        assert_eq!(out.get("customXml/item1.xml").map(Vec::as_slice), Some(DATA.as_bytes()));
+        assert_eq!(out.get("customXml/other.xml"), p.get("customXml/other.xml"));
+        assert!(text(out, "_rels/.rels").contains(r#"Target="customXml/item1.xml""#));
+        assert!(text(out, "word/_rels/document.xml.rels").contains(r#"Target="../customXml/other.xml""#));
+        assert!(text(out, "customXml/_rels/itemProps1.xml.rels").contains(r#"TargetMode="External""#));
+        assert!(text(out, "customXml/_rels/other.xml.rels").contains(r#"Target="itemProps1.xml""#));
+    });
+}
+
+#[test]
+fn absent_and_external_stores_are_not_fetched_or_written() {
+    let mut p = fixture();
+    p.insert(
+        "word/_rels/document.xml.rels".into(),
+        rels(&[
+            ("missing", "customXml", "../customXml/missing.xml", false),
+            ("external", "customXml", "https://example.invalid/store.xml", true),
+            ("valid", "customXml", "../customXml/item1.xml", false),
+        ])
+        .into_bytes(),
+    );
+    p.insert("customXml/_rels/item1.xml.rels".into(), rels(&[("missing", "customXmlProps", "missing.xml", false)]).into_bytes());
+    edited_cycles(&p, |out| {
+        assert_eq!(out.get("customXml/item1.xml").map(Vec::as_slice), Some(DATA.as_bytes()));
+        let roots = text(out, "word/_rels/document.xml.rels");
+        assert!(!roots.contains("missing.xml"));
+        assert!(!roots.contains("example.invalid"));
+        assert!(!out.contains_key("customXml/_rels/item1.xml.rels"));
+    });
+}
+
+#[test]
+fn custom_stores_do_not_shadow_reserved_bibliography_names() {
+    let mut doc = wordcraft_docx::read(&zip(&fixture())).unwrap();
+    doc.sources.push(wordcraft_doc::Source { tag: "OriginalSource".into(), title: "Original synthetic reference".into(), ..Default::default() });
+    let out = unzip(&wordcraft_docx::write(&doc).unwrap());
+    assert_eq!(out.get("customXml/item1_2.xml").map(Vec::as_slice), Some(DATA.as_bytes()));
+    assert_eq!(out.get("customXml/itemProps1_2.xml").map(Vec::as_slice), Some(PROPS.as_bytes()));
+    assert!(text(&out, "word/_rels/document.xml.rels").contains(r#"Target="../customXml/item1_2.xml""#));
+    assert!(text(&out, "customXml/_rels/item1_2.xml.rels").contains(r#"Target="itemProps1_2.xml""#));
+}
+
+#[test]
+fn opaque_non_utf8_data_and_strict_relationship_types_are_preserved() {
+    let mut p = fixture();
+    let data: Vec<u8> =
+        "<?xml version=\"1.0\" encoding=\"UTF-16\"?><customer>Atlas Studios</customer>".encode_utf16().flat_map(u16::to_le_bytes).collect();
+    let mut bytes = vec![0xff, 0xfe];
+    bytes.extend(data);
+    p.insert("customXml/item1.xml".into(), bytes.clone());
+    let strict =
+        rels(&[("strict", "customXml", "../customXml/item1.xml", false)]).replace(RT, "http://purl.oclc.org/ooxml/officeDocument/relationships/");
+    p.insert("word/_rels/document.xml.rels".into(), strict.into_bytes());
+    edited_cycles(&p, |out| {
+        assert_eq!(out.get("customXml/item1.xml"), Some(&bytes));
+        assert!(text(out, "word/_rels/document.xml.rels").contains("http://purl.oclc.org/ooxml/officeDocument/relationships/customXml"));
+    });
+}
+
+#[test]
+fn reserved_part_targets_are_renamed_instead_of_shadowing_or_looping() {
+    let mut p = fixture();
+    p.insert("word/_rels/document.xml.rels".into(), rels(&[("hostile", "customXml", "../docProps/foreign.xml", false)]).into_bytes());
+    p.insert("docProps/foreign.xml".into(), DATA.as_bytes().to_vec());
+    edited_cycles(&p, |out| {
+        assert!(out.values().any(|b| b == DATA.as_bytes()));
+        assert!(!out.contains_key("docProps/foreign.xml"));
+        assert!(text(out, "word/_rels/document.xml.rels").contains(r#"Target="embeddings/part.xml""#));
+        assert!(text(out, "docProps/core.xml").contains("coreProperties"));
+    });
+}
diff --git a/crates/docx/tests/fixtures.rs b/crates/docx/tests/fixtures.rs
index 3331edec44..912d213978 100644
--- a/crates/docx/tests/fixtures.rs
+++ b/crates/docx/tests/fixtures.rs
@@ -47,6 +47,52 @@ fn read_body(body: &str) -> Document {
     wordcraft_docx::read(&docx(body, &[], &[])).unwrap()
 }
 
+#[test]
+fn paragraph_default_presence_survives_repeated_saves() {
+    // Omission leaves paragraph defaults application-defined (ISO 29500 pPrDefault).
+    // An explicitly empty container must therefore remain distinct from omission.
+    for (defaults, present, after) in [
+        ("", false, None),
+        ("<w:docDefaults/>", false, None),
+        ("<w:docDefaults><w:rPrDefault><w:rPr><w:sz w:val=\"22\"/></w:rPr></w:rPrDefault></w:docDefaults>", false, None),
+        ("<w:docDefaults><w:pPrDefault/></w:docDefaults>", true, None),
+        ("<w:docDefaults><w:pPrDefault><w:pPr/></w:pPrDefault></w:docDefaults>", true, None),
+        ("<w:docDefaults><w:pPrDefault><w:pPr><w:spacing w:after=\"160\"/></w:pPr></w:pPrDefault></w:docDefaults>", true, Some(8.0)),
+    ] {
+        let styles = format!(
+            r#"<w:styles {W_NS}>{defaults}<w:style w:type="paragraph" w:styleId="Normal" w:default="1"><w:name w:val="Normal"/></w:style></w:styles>"#
+        );
+        let mut d = wordcraft_docx::read(&docx(
+            "<w:p><w:r><w:t>First</w:t></w:r></w:p><w:p><w:r><w:t>Second</w:t></w:r></w:p>",
+            &[("rId1", "styles", "styles.xml")],
+            &[("word/styles.xml", &styles)],
+        ))
+        .unwrap();
+        for _ in 0..2 {
+            let bytes = wordcraft_docx::write(&d).unwrap();
+            let xml = text(&unzip(&bytes), "word/styles.xml");
+            assert_eq!(xml.contains("<w:pPrDefault>"), present, "{defaults}");
+            d = wordcraft_docx::read(&bytes).unwrap();
+            assert_eq!(d.styles.default_para.space_after, after);
+            assert_eq!(paras(&d).iter().map(|p| p.text.as_str()).collect::<Vec<_>>(), ["First", "Second"]);
+        }
+    }
+}
+
+#[test]
+fn omitted_paragraph_defaults_can_be_edited() {
+    let styles =
+        format!(r#"<w:styles {W_NS}><w:style w:type="paragraph" w:styleId="Normal" w:default="1"><w:name w:val="Normal"/></w:style></w:styles>"#);
+    let mut d = wordcraft_docx::read(&docx("<w:p/>", &[("rId1", "styles", "styles.xml")], &[("word/styles.xml", &styles)])).unwrap();
+    assert!(!d.styles.default_para_present);
+    d.styles.default_para.space_after = Some(12.0);
+    let again = wordcraft_docx::read(&wordcraft_docx::write(&d).unwrap()).unwrap();
+    assert!(again.styles.default_para_present);
+    assert_eq!(again.styles.default_para.space_after, Some(12.0));
+    let new = Document::new();
+    assert_eq!(wordcraft_docx::read(&wordcraft_docx::write(&new).unwrap()).unwrap().styles.default_para, new.styles.default_para);
+}
+
 fn paras(d: &Document) -> Vec<&Paragraph> {
     d.body.iter().filter_map(|b| b.as_para()).collect()
 }
@@ -96,7 +142,9 @@ fn hyperlink_runs_and_wrappers() {
     let bytes = docx(body, &[("rId5", "hyperlink", "https://example.org/")], &[]);
     let d = wordcraft_docx::read(&bytes).unwrap();
     let p = paras(&d);
-    assert_eq!(p[0].text, "siteXABC\u{F04A}\u{2011}\u{AD}\n\u{C}\u{E} e&T");
+    // The content control around "C" is kept (zero-width markers in the text).
+    assert_eq!(p[0].plain_text(), "siteXABC\u{F04A}\u{2011}\u{AD}\n\u{C}\u{E} e&T");
+    assert!(matches!(p[0].objects.first(), Some(InlineObject::ControlStart { .. })));
     assert_eq!(p[0].props_of_char(0).link.as_deref(), Some("https://example.org/"));
     assert_eq!(p[0].props_of_char(0).style.as_deref(), Some("Hyperlink"));
     assert_eq!(p[0].props_of_char(4).link.as_deref(), Some("https://example.org/#frag"));
@@ -104,7 +152,7 @@ fn hyperlink_runs_and_wrappers() {
     assert_eq!(p[0].props_of_char(sym_off).font.as_deref(), Some("Wingdings"));
     let t = p[0].props_of_char(p[0].text.len() - 1);
     assert_eq!((t.bold, t.italic, t.caps, t.strike, t.color), (Some(false), Some(false), Some(false), Some(true), Some(TextColor::Auto)));
-    assert_eq!(p[1].text, "in block sdt");
+    assert_eq!(p[1].plain_text(), "in block sdt");
 }
 
 #[test]
@@ -1082,6 +1130,87 @@ fn formatting_revisions_round_trip() {
     assert_eq!(again.revisions, d.revisions);
 }
 
+/// A package with `styles`, a theme (accent1 4472C4, accent2 ED7D31, major font "Major Face") and,
+/// when given, `settings`.
+fn themed_docx(body: &str, styles: &str, settings: Option<&str>) -> Document {
+    let theme = r#"<a:theme xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" name="T"><a:themeElements><a:clrScheme name="T"><a:dk1><a:sysClr val="windowText" lastClr="000000"/></a:dk1><a:lt1><a:sysClr val="window" lastClr="FFFFFF"/></a:lt1><a:dk2><a:srgbClr val="44546A"/></a:dk2><a:lt2><a:srgbClr val="E7E6E6"/></a:lt2><a:accent1><a:srgbClr val="4472C4"/></a:accent1><a:accent2><a:srgbClr val="ED7D31"/></a:accent2><a:accent3><a:srgbClr val="A5A5A5"/></a:accent3><a:accent4><a:srgbClr val="FFC000"/></a:accent4><a:accent5><a:srgbClr val="5B9BD5"/></a:accent5><a:accent6><a:srgbClr val="70AD47"/></a:accent6><a:hlink><a:srgbClr val="0563C1"/></a:hlink><a:folHlink><a:srgbClr val="954F72"/></a:folHlink></a:clrScheme><a:fontScheme name="T"><a:majorFont><a:latin typeface="Major Face"/></a:majorFont><a:minorFont><a:latin typeface="Minor Face"/></a:minorFont></a:fontScheme></a:themeElements></a:theme>"#;
+    let styles = format!(
+        r#"<w:styles {W_NS}><w:style w:type="paragraph" w:default="1" w:styleId="Normal"><w:name w:val="Normal"/></w:style>{styles}</w:styles>"#
+    );
+    let mut doc_rels = vec![("rId1", "styles", "styles.xml"), ("rId2", "theme", "theme/theme1.xml")];
+    let mut extra = vec![("word/styles.xml", styles.as_str()), ("word/theme/theme1.xml", theme)];
+    let settings = settings.map(|s| format!(r#"<w:settings {W_NS}>{s}</w:settings>"#));
+    if let Some(s) = &settings {
+        doc_rels.push(("rId3", "settings", "settings.xml"));
+        extra.push(("word/settings.xml", s.as_str()));
+    }
+    wordcraft_docx::read(&docx(body, &doc_rels, &extra)).unwrap()
+}
+
+/// Within one step per channel: Word's tint and shade round differently from ours in the last bit.
+fn near(c: Option<TextColor>, want: Rgb) -> bool {
+    matches!(c, Some(TextColor::Rgb(Rgb(r, g, b))) if r.abs_diff(want.0) <= 1 && g.abs_diff(want.1) <= 1 && b.abs_diff(want.2) <= 1)
+}
+
+#[test]
+fn theme_colour_wins_over_the_fixed_colour() {
+    // Heading 1 as Word writes it: the stale w:val is ignored, accent1 darkened 25% is 2F5496.
+    let styles = r#"<w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><w:rPr><w:color w:val="FF0000" w:themeColor="accent1" w:themeShade="BF"/><w:u w:val="single" w:color="FF0000" w:themeColor="accent2"/></w:rPr></w:style>"#;
+    let body = r#"<w:p><w:pPr><w:pStyle w:val="Heading1"/></w:pPr><w:r><w:t>H</w:t></w:r></w:p>
+<w:p><w:r><w:rPr><w:color w:val="000000" w:themeColor="accent1" w:themeTint="99"/></w:rPr><w:t>a</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="accent1" w:themeTint="66"/></w:rPr><w:t>b</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="accent1" w:themeTint="33"/></w:rPr><w:t>c</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="accent1" w:themeShade="7F"/></w:rPr><w:t>d</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="accent2" w:themeShade="BF"/></w:rPr><w:t>e</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="text2"/></w:rPr><w:t>f</w:t></w:r><w:r><w:rPr><w:color w:val="auto" w:themeColor="hyperlink"/></w:rPr><w:t>g</w:t></w:r><w:r><w:rPr><w:shd w:val="clear" w:color="auto" w:fill="000000" w:themeFill="accent2" w:themeFillTint="33"/></w:rPr><w:t>h</w:t></w:r></w:p>"#;
+    let d = themed_docx(body, styles, None);
+    let h = d.styles.get("Heading1").unwrap();
+    assert_eq!(h.chr.color, Some(TextColor::Rgb(Rgb(0x2F, 0x54, 0x96))));
+    assert_eq!(h.chr.underline_color, Some(Rgb(0xED, 0x7D, 0x31)));
+    let p = paras(&d);
+    let at = |i: usize| p[1].props_of_char(i);
+    // Colours Word writes into w:val next to these theme colours (Grid Table and heading styles).
+    assert!(near(at(0).color, Rgb(0x8E, 0xAA, 0xDB)), "{:?}", at(0).color);
+    assert!(near(at(1).color, Rgb(0xB4, 0xC6, 0xE7)), "{:?}", at(1).color);
+    assert!(near(at(2).color, Rgb(0xD9, 0xE2, 0xF3)), "{:?}", at(2).color);
+    assert!(near(at(3).color, Rgb(0x1F, 0x37, 0x63)), "{:?}", at(3).color);
+    assert!(near(at(4).color, Rgb(0xC4, 0x59, 0x11)), "{:?}", at(4).color);
+    // text2 maps to dk2 without a w:clrSchemeMapping; hyperlink to hlink.
+    assert_eq!(at(5).color, Some(TextColor::Rgb(Rgb(0x44, 0x54, 0x6A))));
+    assert_eq!(at(6).color, Some(TextColor::Rgb(Rgb(0x05, 0x63, 0xC1))));
+    let fill = at(7).shading.unwrap();
+    assert!(near(Some(TextColor::Rgb(fill)), Rgb(0xFB, 0xE4, 0xD5)), "{fill:?}");
+}
+
+#[test]
+fn theme_colours_follow_the_colour_scheme_mapping() {
+    // Styles are read before settings; the mapping still applies to them.
+    let styles =
+        r#"<w:style w:type="character" w:styleId="T1"><w:name w:val="T1"/><w:rPr><w:color w:val="000000" w:themeColor="text1"/></w:rPr></w:style>"#;
+    let body = r#"<w:p><w:r><w:rPr><w:rStyle w:val="T1"/></w:rPr><w:t>a</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="background1"/></w:rPr><w:t>b</w:t></w:r><w:r><w:rPr><w:color w:val="000000" w:themeColor="dark1"/></w:rPr><w:t>c</w:t></w:r></w:p>"#;
+    let mapping = r#"<w:clrSchemeMapping w:bg1="dark1" w:t1="accent2" w:bg2="light2" w:t2="dark2" w:accent1="accent1" w:accent2="accent2" w:accent3="accent3" w:accent4="accent4" w:accent5="accent5" w:accent6="accent6" w:hyperlink="hyperlink" w:followedHyperlink="followedHyperlink"/>"#;
+    let d = themed_docx(body, styles, Some(mapping));
+    assert_eq!(d.styles.get("T1").unwrap().chr.color, Some(TextColor::Rgb(Rgb(0xED, 0x7D, 0x31))));
+    let p = paras(&d);
+    assert_eq!(p[0].props_of_char(1).color, Some(TextColor::Rgb(Rgb(0, 0, 0))), "background1 → dark1");
+    assert_eq!(p[0].props_of_char(2).color, Some(TextColor::Rgb(Rgb(0, 0, 0))), "dark1 isn't remapped");
+}
+
+#[test]
+fn theme_colour_without_a_theme_keeps_the_fixed_colour() {
+    let d = read_body(r#"<w:p><w:r><w:rPr><w:color w:val="00FF00" w:themeColor="accent1" w:themeShade="BF"/></w:rPr><w:t>a</w:t></w:r></w:p>"#);
+    assert_eq!(paras(&d)[0].props_of_char(0).color, Some(TextColor::Rgb(Rgb(0, 0xFF, 0))));
+}
+
+#[test]
+fn theme_font_wins_over_the_fixed_font() {
+    let styles = r#"<w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><w:rPr><w:rFonts w:ascii="Calibri Light" w:hAnsi="Calibri Light" w:asciiTheme="majorHAnsi" w:hAnsiTheme="majorHAnsi"/></w:rPr></w:style>"#;
+    let body = r#"<w:p><w:pPr><w:pStyle w:val="Heading1"/></w:pPr><w:r><w:t>H</w:t></w:r></w:p>
+<w:p><w:r><w:rPr><w:rFonts w:hAnsi="Arial" w:hAnsiTheme="minorHAnsi"/></w:rPr><w:t>a</w:t></w:r><w:r><w:rPr><w:rFonts w:ascii="Arial" w:asciiTheme="minorHAnsi"/></w:rPr><w:t>b</w:t></w:r><w:r><w:rPr><w:rFonts w:ascii="Arial" w:hAnsiTheme="majorHAnsi"/></w:rPr><w:t>c</w:t></w:r></w:p>"#;
+    let d = themed_docx(body, styles, None);
+    assert_eq!(d.styles.get("Heading1").unwrap().chr.font.as_deref(), Some("Major Face"));
+    let p = paras(&d);
+    assert_eq!(p[1].props_of_char(0).font.as_deref(), Some("Minor Face"));
+    assert_eq!(p[1].props_of_char(1).font.as_deref(), Some("Minor Face"));
+    // An explicit ascii font still beats a theme font given only for hAnsi.
+    assert_eq!(p[1].props_of_char(2).font.as_deref(), Some("Arial"));
+}
+
 /// Issue #400: moved text (ECMA-376 §17.13.5.21–28). `w:moveFrom` / `w:moveTo` inside named
 /// move ranges are the two ends of one move, paragraph marks included; the ranges are written
 /// back around them. A move missing an end, or whose range never ends, is a plain deletion and
@@ -1172,3 +1301,191 @@ fn note_separators_and_continuation_notice_round_trip() {
     assert!(settings.contains(r#"<w:footnote w:id="-1"/><w:footnote w:id="0"/><w:footnote w:id="1"/>"#), "{settings}");
     check(&wordcraft_docx::read(&out).unwrap());
 }
+
+/// Issue #534: East Asian number formats are read, labelled and written back as they were; a
+/// value the format doesn't define is decimal, and a level without `w:ind` has no indent.
+#[test]
+fn east_asian_number_formats_read_label_and_round_trip() {
+    use wordcraft_doc::numbering::Counters;
+    use wordcraft_doc::section::NumFormat;
+    let lvl = |i: u8, fmt: &str, text: &str| {
+        format!(r#"<w:lvl w:ilvl="{i}"><w:start w:val="1"/><w:numFmt w:val="{fmt}"/><w:suff w:val="nothing"/><w:lvlText w:val="{text}"/></w:lvl>"#)
+    };
+    let levels = [
+        lvl(0, "chineseCounting", "%1、"),
+        lvl(1, "chineseCountingThousand", "第%2章"),
+        lvl(2, "japaneseLegal", "（%3）"),
+        lvl(3, "decimalEnclosedCircle", "%4"),
+        lvl(4, "hebrew1", "%5."),
+        lvl(5, "notAFormat", "%6."),
+    ]
+    .concat();
+    let numbering = format!(
+        r#"<w:numbering {W_NS}><w:abstractNum w:abstractNumId="0">{levels}</w:abstractNum><w:num w:numId="1"><w:abstractNumId w:val="0"/></w:num></w:numbering>"#
+    );
+    let item = |lv: u8| format!(r#"<w:p><w:pPr><w:numPr><w:ilvl w:val="{lv}"/><w:numId w:val="1"/></w:numPr></w:pPr><w:r><w:t>x</w:t></w:r></w:p>"#);
+    let body: String = [0, 0, 0, 1, 2, 3, 4, 5].map(item).concat();
+    let bytes = docx(&body, &[("rId1", "numbering", "numbering.xml")], &[("word/numbering.xml", &numbering)]);
+    let d = wordcraft_docx::read(&bytes).unwrap();
+    let formats = |d: &Document| (0..6).map(|i| d.numbering.level(1, i).map(|l| l.format)).collect::<Vec<_>>();
+    let want = [
+        NumFormat::ChineseCounting,
+        NumFormat::ChineseCountingThousand,
+        NumFormat::JapaneseLegal,
+        NumFormat::DecimalEnclosedCircle,
+        NumFormat::Hebrew1,
+        NumFormat::Decimal,
+    ]
+    .map(Some);
+    assert_eq!(formats(&d), want);
+    assert_eq!(d.numbering.level(1, 0).map(|l| (l.indent, l.hanging)), Some((0.0, 0.0)));
+    let mut c = Counters::default();
+    let labels: Vec<String> =
+        paras(&d).iter().filter_map(|p| p.props.numbering).filter_map(|n| c.next_label(&d.numbering, n.num, n.level)).map(|l| l.0).collect();
+    assert_eq!(labels, ["一、", "二、", "三、", "第一章", "（壱）", "①", "1.", "1."]);
+    // Saved and read again, every format is the one the file had (hebrew1 too, which shows as
+    // decimal for now).
+    let out = wordcraft_docx::write(&d).unwrap();
+    let back = wordcraft_docx::read(&out).unwrap();
+    assert_eq!(formats(&back), want);
+}
+
+/// #464: a bookmark whose end follows the document's final table keeps its end (it goes into
+/// the table's last cell) and is saved as a matched pair.
+#[test]
+fn bookmark_around_final_table_keeps_its_end() {
+    let body = r#"<w:bookmarkStart w:id="7" w:name="TableRange"/><w:tbl><w:tblPr/><w:tblGrid><w:gridCol w:w="1440"/></w:tblGrid><w:tr><w:tc><w:tcPr/><w:p><w:r><w:t>Cell</w:t></w:r></w:p></w:tc></w:tr></w:tbl><w:bookmarkEnd w:id="7"/><w:sectPr/>"#;
+    let d = read_body(body);
+    let marks = |d: &Document| {
+        let Block::Table(t) = &*d.body[0] else { panic!("{:?}", d.body[0]) };
+        t.rows[0].cells[0].blocks[0].as_para().unwrap().objects.clone()
+    };
+    let want = vec![InlineObject::BookmarkStart { name: "TableRange".into() }, InlineObject::BookmarkEnd { name: "TableRange".into() }];
+    assert_eq!(marks(&d), want);
+    let again = wordcraft_docx::read(&wordcraft_docx::write(&d).unwrap()).unwrap();
+    assert_eq!(marks(&again), want);
+    assert_eq!(again.bookmarks().len(), 1);
+}
+
+/// #465: a field whose cached result is an embedded picture (`INCLUDEPICTURE`, simple, complex or
+/// locked) keeps the picture through reading and saving; the linked file is never read.
+#[test]
+fn includepicture_keeps_its_embedded_picture() {
+    let png: &[u8] = b"\x89PNG\r\n\x1a\nstand-in";
+    let pic = r#"<w:r><w:drawing><wp:inline><wp:extent cx="914400" cy="914400"/><wp:docPr id="1" name="P"/><a:graphic><a:graphicData uri="http://schemas.openxmlformats.org/drawingml/2006/picture"><pic:pic><pic:blipFill><a:blip r:embed="rIdPic"/></pic:blipFill></pic:pic></a:graphicData></a:graphic></wp:inline></w:drawing></w:r>"#;
+    let cases = [
+        (format!(r#"<w:fldSimple w:instr="INCLUDEPICTURE &quot;picture.png&quot;">{pic}</w:fldSimple>"#), false),
+        (format!(r#"<w:fldSimple w:instr="INCLUDEPICTURE &quot;picture.png&quot;" w:fldLock="1">{pic}</w:fldSimple>"#), true),
+        (
+            format!(
+                r#"<w:r><w:fldChar w:fldCharType="begin"/></w:r><w:r><w:instrText xml:space="preserve"> INCLUDEPICTURE "picture.png" </w:instrText></w:r><w:r><w:fldChar w:fldCharType="separate"/></w:r>{pic}<w:r><w:fldChar w:fldCharType="end"/></w:r>"#
+            ),
+            false,
+        ),
+    ];
+    for (field, locked) in cases {
+        let bytes = docx(&format!("<w:p>{field}</w:p><w:sectPr/>"), &[("rIdPic", "image", "media/picture.png")], &[]);
+        let bytes = {
+            // `docx` takes text parts; add the picture bytes as a binary part.
+            let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
+            let mut entries: Vec<(String, Vec<u8>)> = Vec::new();
+            for i in 0..z.len() {
+                let mut f = z.by_index(i).unwrap();
+                let mut v = Vec::new();
+                std::io::Read::read_to_end(&mut f, &mut v).unwrap();
+                entries.push((f.name().to_string(), v));
+            }
+            entries.push(("word/media/picture.png".into(), png.to_vec()));
+            zip(&entries.iter().map(|(n, v)| (n.as_str(), v.as_slice())).collect::<Vec<_>>())
+        };
+        let check = |d: &Document| {
+            let p = paras(d);
+            let objs = &p[0].objects;
+            assert_eq!(objs.len(), 3, "{objs:?}");
+            assert_eq!(objs[0], InlineObject::FieldStart { instr: "INCLUDEPICTURE \"picture.png\"".into(), locked });
+            let InlineObject::Image { media, .. } = &objs[1] else { panic!("{objs:?}") };
+            assert_eq!(d.media.get(media).unwrap().as_slice(), png);
+            assert_eq!(objs[2], InlineObject::FieldEnd);
+        };
+        let d = wordcraft_docx::read(&bytes).unwrap();
+        check(&d);
+        check(&wordcraft_docx::read(&wordcraft_docx::write(&d).unwrap()).unwrap());
+    }
+}
+
+/// One anchored Word shape (`wps:wsp` inside `mc:AlternateContent`, as Word writes them) with
+/// shape properties `sppr`, style `style` and extra `wsp` content.
+fn anchored_wsp(name: &str, cx: u32, cy: u32, sppr: &str, style: &str, extra: &str) -> String {
+    format!(
+        r#"<w:r><mc:AlternateContent><mc:Choice Requires="wps"><w:drawing><wp:anchor distT="0" distB="0" distL="114300" distR="114300" simplePos="0" relativeHeight="1" behindDoc="0" locked="0" layoutInCell="1" allowOverlap="1"><wp:simplePos x="0" y="0"/><wp:positionH relativeFrom="column"><wp:posOffset>12700</wp:posOffset></wp:positionH><wp:positionV relativeFrom="paragraph"><wp:posOffset>25400</wp:posOffset></wp:positionV><wp:extent cx="{cx}" cy="{cy}"/><wp:effectExtent l="0" t="0" r="0" b="0"/><wp:wrapNone/><wp:docPr id="1" name="{name}"/><a:graphic><a:graphicData uri="http://schemas.microsoft.com/office/word/2010/wordprocessingShape"><wps:wsp>{extra}<wps:spPr><a:xfrm><a:off x="0" y="0"/><a:ext cx="{cx}" cy="{cy}"/></a:xfrm>{sppr}</wps:spPr>{style}<wps:bodyPr/></wps:wsp></a:graphicData></a:graphic></wp:anchor></w:drawing></mc:Choice><mc:Fallback><w:pict><v:line from="0,0" to="1pt,2pt"/></w:pict></mc:Fallback></mc:AlternateContent></w:r>"#
+    )
+}
+
+/// #611: diagrams drawn with Word's shapes were mostly missing. Connectors and boxes take their
+/// outline and fill from the theme through their style references, or name preset and scheme
+/// colours; all of these are read, with line widths and arrowheads.
+#[test]
+fn theme_styled_connectors_and_callout_boxes_keep_their_paint() {
+    let style = |ln: u8, fill: u8, clr: &str| {
+        format!(
+            r#"<wps:style><a:lnRef idx="{ln}"><a:schemeClr val="{clr}"/></a:lnRef><a:fillRef idx="{fill}"><a:schemeClr val="{clr}"/></a:fillRef><a:effectRef idx="0"><a:schemeClr val="{clr}"/></a:effectRef><a:fontRef idx="minor"><a:schemeClr val="tx1"/></a:fontRef></wps:style>"#
+        )
+    };
+    let body = [
+        // A connector with only a style: accent4, the theme's thinnest line, an arrowhead.
+        anchored_wsp("Arrow", 673100, 889000, r#"<a:prstGeom prst="straightConnector1"><a:avLst/></a:prstGeom><a:ln><a:tailEnd type="triangle"/></a:ln>"#, &style(1, 0, "accent4"), "<wps:cNvCnPr/>"),
+        // A callout text box: scheme fill, preset black outline.
+        anchored_wsp(
+            "Text Box",
+            3073400,
+            673100,
+            r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom><a:solidFill><a:schemeClr val="lt1"/></a:solidFill><a:ln w="6350"><a:solidFill><a:prstClr val="black"/></a:solidFill></a:ln>"#,
+            "",
+            r#"<wps:cNvSpPr txBox="1"/><wps:txbx><w:txbxContent><w:p><w:r><w:t>Callout</w:t></w:r></w:p></w:txbxContent></wps:txbx>"#,
+        ),
+        // A filled rectangle from its style alone.
+        anchored_wsp("Rect", 292100, 647700, r#"<a:prstGeom prst="rect"><a:avLst/></a:prstGeom>"#, &style(2, 1, "accent1"), "<wps:cNvSpPr/>"),
+        // An elbow connector.
+        anchored_wsp("Elbow", 1270000, 635000, r#"<a:prstGeom prst="bentConnector3"><a:avLst/></a:prstGeom>"#, &style(1, 0, "accent2"), "<wps:cNvCnPr/>"),
+        // A rounded-rectangle callout.
+        anchored_wsp("Callout", 1270000, 635000, r#"<a:prstGeom prst="wedgeRoundRectCallout"><a:avLst/></a:prstGeom>"#, &style(2, 1, "accent1"), "<wps:cNvSpPr/>"),
+    ]
+    .concat();
+    let d = read_body(&format!("<w:p>{body}</w:p>"));
+    let theme = &d.settings.theme_colors;
+    let objs = &paras(&d)[0].objects;
+    assert_eq!(objs.len(), 5);
+    let shape = |i: usize| match &objs[i] {
+        InlineObject::Shape { kind, fill, stroke, stroke_width, extra, story, .. } => {
+            (*kind, *fill, *stroke, *stroke_width, extra.arrow_end, story.is_some())
+        }
+        o => panic!("{o:?}"),
+    };
+    assert_eq!(shape(0), (ShapeKind::StraightConnector, None, Some(theme[7]), 0.5, true, false));
+    assert_eq!(shape(1), (ShapeKind::TextBox, Some(theme[1]), Some(Rgb(0, 0, 0)), 0.5, false, true));
+    assert_eq!(shape(2), (ShapeKind::Rectangle, Some(theme[4]), Some(theme[4]), 1.0, false, false));
+    assert_eq!(shape(3), (ShapeKind::ElbowConnector, None, Some(theme[5]), 0.5, false, false));
+    assert_eq!(shape(4).0, ShapeKind::RoundedRectangle);
+    // The themed outline and the arrowhead survive saving.
+    let again = wordcraft_docx::read(&wordcraft_docx::write(&d).unwrap()).unwrap();
+    assert!(matches!(&paras(&again)[0].objects[0], InlineObject::Shape { stroke, extra, .. } if *stroke == Some(theme[7]) && extra.arrow_end));
+}
+
+/// #611: legacy VML lines and rectangles (documents without DrawingML).
+#[test]
+fn vml_lines_and_rectangles() {
+    let body = r##"<w:p><w:r><w:pict><v:line style="position:absolute;flip:y;z-index:1" from="10pt,20pt" to="40pt,60pt" strokecolor="#4472c4 [3204]" strokeweight=".5pt"><v:stroke endarrow="block"/></v:line></w:pict></w:r>
+<w:r><w:pict><v:rect style="position:absolute;margin-left:5pt;margin-top:6pt;width:30pt;height:20pt" fillcolor="#ff0000" stroked="f"/></w:pict></w:r></w:p>"##;
+    let d = read_body(body);
+    let objs = &paras(&d)[0].objects;
+    assert_eq!(objs.len(), 2, "{objs:?}");
+    match &objs[0] {
+        InlineObject::Shape { kind: ShapeKind::Line, w, h, stroke, stroke_width, float, extra, .. } => {
+            assert_eq!((*w, *h, *stroke, *stroke_width), (30.0, 40.0, Some(Rgb(0x44, 0x72, 0xC4)), 0.5));
+            assert_eq!((float.x, float.y, float.flip_h, float.flip_v), (10.0, 20.0, false, true));
+            assert!(extra.arrow_end && !extra.arrow_start);
+        }
+        o => panic!("{o:?}"),
+    }
+    assert!(matches!(&objs[1], InlineObject::Shape { kind: ShapeKind::Rectangle, fill: Some(Rgb(255, 0, 0)), stroke: None, w: 30.0, h: 20.0, .. }));
+}
diff --git a/crates/docx/tests/malformed.rs b/crates/docx/tests/malformed.rs
index 3c4d8c23cb..f1725d8621 100644
--- a/crates/docx/tests/malformed.rs
+++ b/crates/docx/tests/malformed.rs
@@ -163,6 +163,51 @@ const SNIPPETS: &[&str] = &[
     "<w:sectPr/>",
 ];
 
+#[test]
+fn malformed_or_hostile_bibliography_never_panics() {
+    let doc = format!("<w:document {W_NS}><w:body><w:p><w:r><w:t>body</w:t></w:r></w:p></w:body></w:document>");
+    let cases: &[&[u8]] = &[
+        b"<not_sources/>",
+        b"<b:Sources xmlns:b=\"http://schemas.openxmlformats.org/officeDocument/2006/bibliography\"><unclosed",
+        b"<b:Sources xmlns:b=\"http://schemas.openxmlformats.org/officeDocument/2006/bibliography\"><b:Source/></b:Sources>",
+        b"<b:Sources xmlns:b=\"http://schemas.openxmlformats.org/officeDocument/2006/bibliography\"><b:Source><b:Author><b:NameList><b:Person/></b:NameList></b:Author></b:Source></b:Sources>",
+        b"<b:Sources xmlns:b=\"http://schemas.openxmlformats.org/officeDocument/2006/bibliography\"><b:Source><b:Tag></b:Tag><b:SourceType></b:SourceType><b:Author><b:NameList><b:Person><b:Last>,,,,</b:Last><b:First></b:First></b:Person></b:NameList></b:Author></b:Source></b:Sources>",
+        b"<b:Sources xmlns:b=\"http://schemas.openxmlformats.org/officeDocument/2006/bibliography\"><b:Source><b:Author><b:Editor><b:NameList><b:Person><b:Last>Ed</b:Last></b:Person></b:NameList></b:Editor></b:Author><b:Edition>1st</b:Edition><b:Issue>99</b:Issue><b:Month>13</b:Month><b:Day>32</b:Day><b:YearAccessed>2025</b:YearAccessed><b:MonthAccessed>02</b:MonthAccessed><b:DayAccessed>30</b:DayAccessed><b:StandardNumber>doi:10.0/0</b:StandardNumber></b:Source></b:Sources>",
+        b"<b:Sources xmlns:b=\"http://schemas.openxmlformats.org/officeDocument/2006/bibliography\"><b:Source><b:Tag>Hostile1</b:Tag><b:Editor><b:Person/></b:Editor><b:Accessed>---///---</b:Accessed></b:Source></b:Sources>",
+        b"\xff\xfe<\0b\0:\0S\0",
+    ];
+    let root_rels_bib = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml" Target="customXml/item1.xml"/></Relationships>"#;
+    for case in cases {
+        let z = zip(&[("_rels/.rels", root_rels_bib.as_bytes()), ("word/document.xml", doc.as_bytes()), ("customXml/item1.xml", case)]);
+        let res = read(&z);
+        if let Ok(d) = res {
+            let _ = write(&d);
+        }
+    }
+}
+
+/// A file with a huge number of bibliography sources (duplicates and distinct ones) reads in
+/// linear time and keeps at most 10,000 of them.
+#[test]
+fn hostile_bibliography_source_count_is_capped() {
+    let doc = format!("<w:document {W_NS}><w:body><w:p><w:r><w:t>body</w:t></w:r></w:p></w:body></w:document>");
+    let mut sources = String::from(r#"<b:Sources xmlns:b="http://schemas.openxmlformats.org/officeDocument/2006/bibliography" StyleName="MLA">"#);
+    for i in 0..60_000 {
+        sources.push_str(&format!("<b:Source><b:Tag>T{i}</b:Tag><b:Title>Title {i}</b:Title></b:Source>"));
+        // Untagged duplicates all collapse into one source.
+        sources.push_str("<b:Source><b:Title>Same</b:Title></b:Source>");
+    }
+    sources.push_str("</b:Sources>");
+    let root_rels = r#"<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/><Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml" Target="customXml/item1.xml"/></Relationships>"#;
+    let z = zip(&[("_rels/.rels", root_rels.as_bytes()), ("word/document.xml", doc.as_bytes()), ("customXml/item1.xml", sources.as_bytes())]);
+    let start = std::time::Instant::now();
+    let d = read(&z).unwrap();
+    assert_eq!(d.sources.len(), 10_000);
+    assert_eq!(d.sources.iter().filter(|s| s.tag.is_empty()).count(), 1, "untagged duplicates are kept once");
+    assert_eq!(d.settings.bib_style.as_deref(), Some("MLA"));
+    assert!(start.elapsed() < std::time::Duration::from_secs(30), "took {:?}", start.elapsed());
+}
+
 proptest! {
     #![proptest_config(ProptestConfig { cases: 300, ..ProptestConfig::default() })]
 
diff --git a/crates/docx/tests/roundtrip.rs b/crates/docx/tests/roundtrip.rs
index 612fbdb477..4d9759616c 100644
--- a/crates/docx/tests/roundtrip.rs
+++ b/crates/docx/tests/roundtrip.rs
@@ -11,7 +11,7 @@ use wordcraft_doc::props::{
 use wordcraft_doc::section::{Columns, DocGrid, DocGridType, LineNumberRestart, LineNumbering, NumFormat, SectionProps, SectionStart};
 use wordcraft_doc::styles::{Style, StyleKind};
 use wordcraft_doc::table::{Cell, Table};
-use wordcraft_doc::{Block, Blocks, Comment, Document, InlineObject, Paragraph, PartKind, Revision, RevisionKind, Watermark, para_block};
+use wordcraft_doc::{Block, Blocks, Comment, Document, InlineObject, Paragraph, PartKind, Revision, RevisionKind, Source, Watermark, para_block};
 
 fn rt(doc: &Document) -> Document {
     let bytes = wordcraft_docx::write(doc).expect("write");
@@ -79,11 +79,33 @@ fn every_char_prop_round_trips() {
         shadow: Some(true),
         emboss: Some(false),
         engrave: Some(true),
+        // WordArt effects ([MS-DOCX] w14 run properties).
+        text_effects: Some(Box::new(wordcraft_doc::wordart::TextEffects {
+            fill: Some(wordcraft_doc::wordart::TextFill::Gradient {
+                stops: vec![
+                    wordcraft_doc::wordart::GradStop { pos: 0.0, color: Rgb(0x15, 0x60, 0x82), transparency: 0.0 },
+                    wordcraft_doc::wordart::GradStop { pos: 100.0, color: Rgb(0xE9, 0x71, 0x32), transparency: 25.0 },
+                ],
+                angle: 90.0,
+            }),
+            outline: Some(wordcraft_doc::wordart::TextOutline { color: Some(Rgb(0x0E, 0x28, 0x41)), width: 1.5, transparency: 0.0 }),
+            shadow: Some(wordcraft_doc::effects::Shadow {
+                color: Rgb::BLACK,
+                transparency: 60.0,
+                blur: 4.0,
+                distance: 3.0,
+                angle: 45.0,
+                rot_with_shape: false,
+            }),
+            glow: Some(wordcraft_doc::effects::Glow { color: Rgb(0x0F, 0x9E, 0xD5), size: 5.0, transparency: 40.0 }),
+            reflection: Some(wordcraft_doc::wordart::Reflection::default()),
+        })),
         lang: Some("fr-FR".into()),
         no_proof: Some(true),
         rtl: Some(false),
         cs: Some(true),
         font_cs: Some("B Nazanin".into()),
+        font_ea: Some("宋体".into()),
         size_cs: Some(13.0),
         bold_cs: Some(false),
         italic_cs: Some(true),
@@ -114,10 +136,14 @@ fn every_para_prop_round_trips() {
         indent_left: Some(36.0),
         indent_right: Some(18.0),
         indent_first: Some(-18.0),
+        indent_left_chars: Some(1.5),
+        indent_right_chars: Some(0.0),
+        indent_first_chars: Some(-1.0),
         space_before: Some(6.0),
         space_after: Some(12.0),
         line_spacing: Some(LineSpacing::Multiple(1.5)),
         contextual_spacing: Some(true),
+        mirror_indents: Some(true),
         keep_next: Some(true),
         keep_lines: Some(false),
         page_break_before: Some(true),
@@ -187,6 +213,7 @@ fn styles_and_lists_round_trip() {
         quick: true,
         hidden: false,
         builtin: false,
+        locked: true,
         table: None,
     });
     d.styles.upsert(Style {
@@ -736,6 +763,7 @@ fn toc_field_skips_nested_stories() {
             story: Some(story),
             freeform: None,
             effects: Default::default(),
+            extra: Default::default(),
         }
     };
     let mut head = Paragraph::with_text("Contents", CharProps::default()).styled("TOCHeading");
@@ -859,6 +887,7 @@ fn shapes_textboxes_equations_dropcaps_round_trip() {
         story: Some(story),
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     let star = InlineObject::Shape {
         kind: ShapeKind::Star,
@@ -871,6 +900,7 @@ fn shapes_textboxes_equations_dropcaps_round_trip() {
         story: None,
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     let eq = InlineObject::Equation { linear: "x=(-b±√(b^2-4ac))/2a".into(), display: false, math: Default::default() };
     let mut p = Paragraph::with_text("shapes ", CharProps::default());
@@ -942,6 +972,7 @@ fn groups_round_trip() {
             glow: None,
             soft_edge: Some(2.5),
         },
+        extra: Default::default(),
     };
     let tb = InlineObject::Shape {
         kind: ShapeKind::TextBox,
@@ -954,6 +985,7 @@ fn groups_round_trip() {
         story: Some(story),
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     let float = Float { wrap: Wrap::Square, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x: 20.0, y: 10.0, dist: 9.0, ..Default::default() };
     let group = InlineObject::Group {
@@ -1015,6 +1047,7 @@ fn drawing_canvas_round_trips() {
         story: None,
         effects: Default::default(),
         freeform: None,
+        extra: Default::default(),
     };
     let style = CanvasStyle { fill: Some(Rgb(0xF0, 0xF4, 0xFF)), stroke: Some(Rgb(0x20, 0x40, 0x80)), stroke_width: 1.5 };
     let canvas = InlineObject::Group {
@@ -1062,6 +1095,7 @@ fn rotated_drawing_canvas_round_trips() {
         story: None,
         effects: Default::default(),
         freeform: None,
+        extra: Default::default(),
     };
     let canvas = |float: Float| InlineObject::Group {
         w: 200.0,
@@ -1108,6 +1142,38 @@ fn compatibility_mode_round_trips() {
     }
 }
 
+/// Tools › Templates and Add-ins: the attached template (an external relationship of the settings
+/// part) and "Automatically update document styles" (`w:linkStyles`) round-trip, written in the
+/// schema's order (after `w:mirrorMargins`, before `w:trackRevisions`).
+#[test]
+fn attached_template_and_link_styles_round_trip() {
+    let mut d = Document::new();
+    d.settings.attached_template = Some("file:///C:/Templates/Report & Co.dotx".into());
+    d.settings.link_styles = true;
+    d.settings.mirror_margins = true;
+    d.settings.track_changes = true;
+    let bytes = wordcraft_docx::write(&d).expect("write");
+    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
+    let mut xml = String::new();
+    std::io::Read::read_to_string(&mut zip.by_name("word/settings.xml").unwrap(), &mut xml).unwrap();
+    let at = |tag: &str| xml.find(tag).unwrap_or_else(|| panic!("{tag} missing: {xml}"));
+    assert!(at("<w:mirrorMargins") < at("<w:attachedTemplate"));
+    assert!(at("<w:attachedTemplate") < at("<w:linkStyles"));
+    assert!(at("<w:linkStyles") < at("<w:trackRevisions"));
+    let mut rels = String::new();
+    std::io::Read::read_to_string(&mut zip.by_name("word/_rels/settings.xml.rels").unwrap(), &mut rels).unwrap();
+    assert!(rels.contains("relationships/attachedTemplate") && rels.contains("TargetMode=\"External\""), "{rels}");
+
+    let r = wordcraft_docx::read(&bytes).expect("read");
+    assert_eq!(r.settings.attached_template.as_deref(), Some("file:///C:/Templates/Report & Co.dotx"));
+    assert!(r.settings.link_styles);
+
+    // Detached: neither element nor relationship is written.
+    let plain = rt(&Document::new());
+    assert_eq!(plain.settings.attached_template, None);
+    assert!(!plain.settings.link_styles);
+}
+
 #[test]
 fn settings_core_theme_round_trip() {
     let mut d = Document::new();
@@ -1116,6 +1182,10 @@ fn settings_core_theme_round_trip() {
     d.settings.even_odd_headers = true;
     d.settings.mirror_margins = true;
     d.settings.auto_hyphenation = true;
+    // Hyphenation Options (#407): zone, words in capitals, consecutive hyphens.
+    d.settings.hyphenation_zone = 27.0;
+    d.settings.hyphenate_caps = false;
+    d.settings.consecutive_hyphen_limit = 2;
     d.settings.page_color = Some(Rgb(250, 240, 230));
     d.settings.major_font = "Cambria".into();
     d.settings.minor_font = "Calibri".into();
@@ -1190,6 +1260,21 @@ fn kitchen_sink() -> Document {
     blocks.push(Arc::new(Block::Table(t)));
     blocks.push(para_block(Paragraph::new()));
     d.body = blocks;
+    d.sources.push(Source {
+        tag: "Sink2026".into(),
+        kind: "book".into(),
+        author: "Author, First".into(),
+        title: "Title".into(),
+        year: "2026".into(),
+        editor: "Editor, Chief".into(),
+        edition: "3rd".into(),
+        issue: "2".into(),
+        month: "08".into(),
+        day: "24".into(),
+        accessed: "2026-08-25".into(),
+        doi: "10.1234/sink.2026".into(),
+        ..Default::default()
+    });
     d
 }
 
@@ -1205,9 +1290,25 @@ fn second_generation_is_stable() {
     assert_eq!(d2.revisions, d1.revisions);
     assert_eq!(d2.settings, d1.settings);
     assert_eq!(d2.media, d1.media);
+    assert_eq!(d2.sources, d1.sources);
     assert_eq!(d2, d1);
 }
 
+/// A Word XML Document (Flat OPC) carries the same package as a .docx: reading it back gives
+/// what the .docx round trip gives, pictures included (#548).
+#[test]
+fn flat_opc_round_trip_equals_docx() {
+    let d = kitchen_sink();
+    let xml = wordcraft_docx::write_flat(&d).expect("write flat");
+    let text = std::str::from_utf8(&xml).expect("utf-8");
+    assert!(text.starts_with("<?xml") && text.contains("<?mso-application progid=\"Word.Document\"?>"));
+    assert!(text.contains("pkg:name=\"/word/document.xml\"") && text.contains("<pkg:binaryData>"));
+    assert_eq!(wordcraft_docx::sniff_xml(&xml), wordcraft_docx::XmlKind::FlatOpc);
+    let back = wordcraft_docx::read_xml(&xml).expect("read flat");
+    assert_eq!(back, rt(&d));
+    assert_eq!(back.media.len(), 1);
+}
+
 #[test]
 fn builtin_stylesheet_survives() {
     let d = Document::new();
@@ -1291,6 +1392,7 @@ fn self_showing_text_box_saves_bounded() {
         story: Some(id),
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     for _ in 0..30 {
         d.insert_object(
@@ -1373,7 +1475,8 @@ fn list_level_overrides_round_trip() {
 }
 
 /// Ink strokes and freeform shapes are written as DrawingML custom geometry (`a:custGeom`,
-/// `a:moveTo`/`a:lnTo`) in floating drawings and read back with their points, pen and opacity.
+/// `a:moveTo`/`a:lnTo`) in floating drawings and read back with their points, pen, opacity and
+/// drawing order.
 #[test]
 fn ink_and_freeforms_round_trip_as_custom_geometry() {
     use wordcraft_doc::freeform::{FreePath, Freeform, InkTool};
@@ -1388,8 +1491,15 @@ fn ink_and_freeforms_round_trip_as_custom_geometry() {
         story: None,
         freeform: Some(Arc::new(f)),
         effects: Default::default(),
+        extra: Default::default(),
     };
-    let pen = shape(None, 2.0, Wrap::InFrontOfText, Freeform::ink(InkTool::Pen, 60.0, 20.0, vec![[1.0, 1.0], [30.0, 19.0], [59.0, 4.0]]));
+    // The pen stroke was the seventh drawn: Ink Replay's order comes back too.
+    let pen = shape(
+        None,
+        2.0,
+        Wrap::InFrontOfText,
+        Freeform { order: Some(7), ..Freeform::ink(InkTool::Pen, 60.0, 20.0, vec![[1.0, 1.0], [30.0, 19.0], [59.0, 4.0]]) },
+    );
     let marker = shape(None, 12.0, Wrap::BehindText, Freeform::ink(InkTool::Highlighter, 80.0, 12.0, vec![[6.0, 6.0], [74.0, 6.0]]));
     let triangle = Freeform {
         w: 40.0,
@@ -1441,6 +1551,7 @@ fn shape_effects_round_trip() {
         story: None,
         freeform: None,
         effects,
+        extra: Default::default(),
     };
     let mut p = Paragraph::with_text("x", CharProps::default());
     p.insert_object(1, shape, &CharProps::default()).unwrap();
@@ -1516,6 +1627,7 @@ fn rotation_and_flips_round_trip() {
         story: None,
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     let square = Float { wrap: Wrap::Square, ..Default::default() };
     let tri = shape(ShapeKind::Triangle, Float { rot: 90.0, flip_h: true, ..square.clone() });
@@ -1572,6 +1684,7 @@ fn rotated_group_and_shadow_rotation_round_trip() {
         story: None,
         freeform: None,
         effects: ShapeEffects { shadow: Some(Shadow { rot_with_shape, ..Default::default() }), ..Default::default() },
+        extra: Default::default(),
     };
     let group = InlineObject::Group {
         w: 120.0,
@@ -1606,6 +1719,154 @@ fn rotated_group_and_shadow_rotation_round_trip() {
     assert_eq!(got, [(20.0, Some(true)), (20.0, Some(false))]);
 }
 
+#[test]
+fn bibliography_sources_round_trip() {
+    let mut d = Document::new();
+    d.sources.push(Source {
+        tag: "Rivera2021".into(),
+        kind: "book".into(),
+        author: "Rivera, Alex; Chen, Mei".into(),
+        title: "Shared Spaces".into(),
+        year: "2021".into(),
+        publisher: "Harbor Books".into(),
+        city: "Portland".into(),
+        editor: "Johnson, Robert".into(),
+        edition: "2nd".into(),
+        month: "10".into(),
+        day: "15".into(),
+        ..Default::default()
+    });
+    d.sources.push(Source {
+        tag: "Smith2023".into(),
+        kind: "article".into(),
+        author: "Smith, John David".into(),
+        title: "Modern Typography".into(),
+        year: "2023".into(),
+        journal: "Design Quarterly".into(),
+        volume: "12".into(),
+        pages: "45-60".into(),
+        url: "https://example.com/typo".into(),
+        issue: "4".into(),
+        doi: "10.1000/182".into(),
+        ..Default::default()
+    });
+    d.sources.push(Source {
+        tag: "WebSite2024".into(),
+        kind: "website".into(),
+        author: "Solo".into(),
+        title: "Open Fonts".into(),
+        year: "2024".into(),
+        url: "https://example.org".into(),
+        accessed: "2024-05-15".into(),
+        ..Default::default()
+    });
+    d.sources.push(Source {
+        tag: "Chapter2025".into(),
+        kind: "bookSection".into(),
+        author: "Lee, Harper".into(),
+        title: "Chapter One".into(),
+        year: "2025".into(),
+        journal: "Anthology of Prose".into(),
+        pages: "1-20".into(),
+        ..Default::default()
+    });
+    d.sources.push(Source {
+        tag: "Misc2026".into(),
+        kind: "other".into(),
+        title: "Archive Manuscript".into(),
+        year: "2026".into(),
+        city: "Oxford".into(),
+        ..Default::default()
+    });
+
+    let bytes = wordcraft_docx::write(&d).expect("write");
+    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
+
+    // Verify package-root customXml parts exist
+    assert!(zip.by_name("customXml/item1.xml").is_ok());
+    assert!(zip.by_name("customXml/itemProps1.xml").is_ok());
+    assert!(zip.by_name("customXml/_rels/item1.xml.rels").is_ok());
+
+    let mut rels_xml = String::new();
+    std::io::Read::read_to_string(&mut zip.by_name("_rels/.rels").unwrap(), &mut rels_xml).unwrap();
+    assert!(rels_xml.contains("relationships/customXml"), "{rels_xml}");
+    assert!(rels_xml.contains("Target=\"customXml/item1.xml\""), "{rels_xml}");
+
+    let mut ct_xml = String::new();
+    std::io::Read::read_to_string(&mut zip.by_name("[Content_Types].xml").unwrap(), &mut ct_xml).unwrap();
+    assert!(ct_xml.contains("PartName=\"/customXml/item1.xml\""), "{ct_xml}");
+    assert!(ct_xml.contains("PartName=\"/customXml/itemProps1.xml\""), "{ct_xml}");
+
+    let mut item_xml = String::new();
+    std::io::Read::read_to_string(&mut zip.by_name("customXml/item1.xml").unwrap(), &mut item_xml).unwrap();
+    assert!(item_xml.contains("SelectedStyle=\"\\APA.XSL\""), "{item_xml}");
+    assert!(item_xml.contains("StyleName=\"APA\""), "{item_xml}");
+    assert!(item_xml.contains("<b:SourceType>Book</b:SourceType>"), "{item_xml}");
+    assert!(item_xml.contains("<b:SourceType>JournalArticle</b:SourceType>"), "{item_xml}");
+    assert!(item_xml.contains("<b:SourceType>InternetSite</b:SourceType>"), "{item_xml}");
+    assert!(item_xml.contains("<b:SourceType>BookSection</b:SourceType>"), "{item_xml}");
+    assert!(item_xml.contains("<b:SourceType>Misc</b:SourceType>"), "{item_xml}");
+    assert!(item_xml.contains("<b:Author><b:Author><b:NameList><b:Person>"), "{item_xml}");
+    assert!(item_xml.contains("<b:Last>Rivera</b:Last><b:First>Alex</b:First>"), "{item_xml}");
+    assert!(item_xml.contains("<b:Last>Smith</b:Last><b:First>John</b:First><b:Middle>David</b:Middle>"), "{item_xml}");
+    assert!(item_xml.contains("<b:Last>Solo</b:Last>"), "{item_xml}");
+    assert!(item_xml.contains("<b:Editor>"), "{item_xml}");
+    assert!(item_xml.contains("<b:Last>Johnson</b:Last><b:First>Robert</b:First>"), "{item_xml}");
+    assert!(item_xml.contains("<b:Edition>2nd</b:Edition>"), "{item_xml}");
+    assert!(item_xml.contains("<b:Month>10</b:Month>"), "{item_xml}");
+    assert!(item_xml.contains("<b:Day>15</b:Day>"), "{item_xml}");
+    assert!(item_xml.contains("<b:Issue>4</b:Issue>"), "{item_xml}");
+    assert!(item_xml.contains("<b:DOI>10.1000/182</b:DOI>"), "{item_xml}");
+    assert!(item_xml.contains("<b:YearAccessed>2024</b:YearAccessed>"), "{item_xml}");
+    assert!(item_xml.contains("<b:MonthAccessed>05</b:MonthAccessed>"), "{item_xml}");
+    assert!(item_xml.contains("<b:DayAccessed>15</b:DayAccessed>"), "{item_xml}");
+    assert!(item_xml.contains("<b:Accessed>2024-05-15</b:Accessed>"), "{item_xml}");
+
+    let back = wordcraft_docx::read(&bytes).expect("read");
+    assert_eq!(back.sources.len(), 5);
+    assert_eq!(back.sources[0].tag, "Rivera2021");
+    assert_eq!(back.sources[0].kind, "book");
+    assert_eq!(back.sources[0].author, "Rivera, Alex; Chen, Mei");
+    assert_eq!(back.sources[0].title, "Shared Spaces");
+    assert_eq!(back.sources[0].year, "2021");
+    assert_eq!(back.sources[0].publisher, "Harbor Books");
+    assert_eq!(back.sources[0].city, "Portland");
+    assert_eq!(back.sources[0].editor, "Johnson, Robert");
+    assert_eq!(back.sources[0].edition, "2nd");
+    assert_eq!(back.sources[0].month, "10");
+    assert_eq!(back.sources[0].day, "15");
+
+    assert_eq!(back.sources[1].tag, "Smith2023");
+    assert_eq!(back.sources[1].kind, "article");
+    assert_eq!(back.sources[1].author, "Smith, John David");
+    assert_eq!(back.sources[1].title, "Modern Typography");
+    assert_eq!(back.sources[1].journal, "Design Quarterly");
+    assert_eq!(back.sources[1].volume, "12");
+    assert_eq!(back.sources[1].pages, "45-60");
+    assert_eq!(back.sources[1].url, "https://example.com/typo");
+    assert_eq!(back.sources[1].issue, "4");
+    assert_eq!(back.sources[1].doi, "10.1000/182");
+
+    assert_eq!(back.sources[2].tag, "WebSite2024");
+    assert_eq!(back.sources[2].kind, "website");
+    assert_eq!(back.sources[2].author, "Solo");
+    assert_eq!(back.sources[2].title, "Open Fonts");
+    assert_eq!(back.sources[2].url, "https://example.org");
+    assert_eq!(back.sources[2].accessed, "2024-05-15");
+
+    assert_eq!(back.sources[3].tag, "Chapter2025");
+    assert_eq!(back.sources[3].kind, "bookSection");
+    assert_eq!(back.sources[3].author, "Lee, Harper");
+    assert_eq!(back.sources[3].title, "Chapter One");
+    assert_eq!(back.sources[3].journal, "Anthology of Prose");
+    assert_eq!(back.sources[3].pages, "1-20");
+
+    assert_eq!(back.sources[4].tag, "Misc2026");
+    assert_eq!(back.sources[4].kind, "other");
+    assert_eq!(back.sources[4].title, "Archive Manuscript");
+    assert_eq!(back.sources[4].city, "Oxford");
+}
+
 #[test]
 fn wrap_polygons_round_trip() {
     use wordcraft_doc::wrap::{WrapPolygon, shape_outline};
@@ -1621,6 +1882,7 @@ fn wrap_polygons_round_trip() {
         story: None,
         effects: Default::default(),
         freeform: None,
+        extra: Default::default(),
     };
     // A hand-edited polygon, including points outside the frame.
     let poly = WrapPolygon::new(true, [(-300, 0), (21_600, 1200), (18_000, 21_900), (0, 21_600)]).map(Arc::new);
@@ -1744,6 +2006,7 @@ fn wrap_text_sides_round_trip() {
         story: None,
         effects: Default::default(),
         freeform: None,
+        extra: Default::default(),
     };
     let sides =
         [(Wrap::Square, WrapText::Left), (Wrap::Tight, WrapText::Right), (Wrap::Through, WrapText::Largest), (Wrap::Square, WrapText::BothSides)];
@@ -1771,3 +2034,162 @@ fn wrap_text_sides_round_trip() {
     // A value outside the schema is no side (read as both sides).
     assert_eq!(WrapText::from_ooxml("middle"), None);
 }
+
+#[test]
+fn alt_text_title_and_decorative_round_trip_for_every_object() {
+    use wordcraft_doc::para::AltText;
+    let mut d = Document::new();
+    let key = d.add_media(tiny_png(), "png");
+    let pic = InlineObject::Image {
+        media: key,
+        w: 100.0,
+        h: 50.0,
+        alt: "A kiln at dusk".into(),
+        float: Float { alt: AltText { title: "Kiln".into(), ..Default::default() }, ..Default::default() },
+        crop: [0.0; 4],
+        ole: None,
+    };
+    let shape = |alt: AltText| InlineObject::Shape {
+        kind: ShapeKind::Ellipse,
+        w: 80.0,
+        h: 40.0,
+        fill: Some(Rgb(1, 2, 3)),
+        stroke: None,
+        stroke_width: 0.0,
+        float: Float { alt, ..Default::default() },
+        story: None,
+        effects: Default::default(),
+        freeform: None,
+        extra: Default::default(),
+    };
+    let described = shape(AltText { text: "Process flow & \"steps\"".into(), ..Default::default() });
+    let decorative = shape(AltText { decorative: true, ..Default::default() });
+    let group = InlineObject::Group {
+        w: 120.0,
+        h: 60.0,
+        float: Float { alt: AltText { text: "Two circles".into(), ..Default::default() }, ..Default::default() },
+        ch_w: 120.0,
+        ch_h: 60.0,
+        children: vec![wordcraft_doc::para::GroupChild { x: 0.0, y: 0.0, obj: shape(AltText { text: "Left circle".into(), ..Default::default() }) }],
+        canvas: None,
+    };
+    let mut p = Paragraph::with_text("objects ", CharProps::default());
+    for o in [pic, described, decorative, group] {
+        let end = p.len();
+        p.insert_object(end, o, &CharProps::default()).unwrap();
+    }
+    let mut t = Table::new(2, 2, 300.0);
+    t.props.caption = Some("Prices".into());
+    t.props.description = Some("Prices by year".into());
+    d.body = vec![para_block(p), Arc::new(Block::Table(t))];
+    let bytes = wordcraft_docx::write(&d).expect("write");
+    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
+    let mut xml = String::new();
+    std::io::Read::read_to_string(&mut zip.by_name("word/document.xml").unwrap(), &mut xml).unwrap();
+    assert!(xml.contains(r#"{C183D7F6-B498-43B3-948B-1728B52AA6E4}"><adec:decorative xmlns:adec="http://schemas.microsoft.com/office/drawing/2017/decorative" val="1"/>"#), "{xml}");
+    assert!(
+        xml.contains(r#"<w:tblLook "#) && xml.contains(r#"<w:tblCaption w:val="Prices"/><w:tblDescription w:val="Prices by year"/></w:tblPr>"#),
+        "{xml}"
+    );
+    let r = wordcraft_docx::read(&bytes).expect("read");
+    let objs = &paras(&r)[0].objects;
+    let alts: Vec<_> =
+        objs.iter().map(|o| (o.alt_text().to_string(), o.frame().map(|f| f.2.alt.title.clone()).unwrap_or_default(), o.is_decorative())).collect();
+    assert_eq!(
+        alts,
+        [
+            ("A kiln at dusk".into(), "Kiln".into(), false),
+            ("Process flow & \"steps\"".into(), String::new(), false),
+            (String::new(), String::new(), true),
+            ("Two circles".into(), String::new(), false),
+        ]
+    );
+    let InlineObject::Group { children, .. } = &objs[3] else { panic!("{objs:?}") };
+    assert_eq!(children[0].obj.alt_text(), "Left circle");
+    let Some(Block::Table(t)) = r.body.iter().map(|b| &**b).find(|b| matches!(b, Block::Table(_))) else { panic!() };
+    assert_eq!((t.props.caption.as_deref(), t.props.description.as_deref()), (Some("Prices"), Some("Prices by year")));
+}
+
+/// WordArt's warp (`a:prstTxWarp` with its adjust value) and connectors glued to shapes
+/// (`a:stCxn`/`a:endCxn`, with arrowheads) come back as saved; a shape no connector is glued to
+/// loses its drawing id, and hostile values are reduced.
+#[test]
+fn warps_and_glued_connectors_round_trip() {
+    use wordcraft_doc::connector::{ConnEnd, ShapeExtra};
+    use wordcraft_doc::wordart::TextWarp;
+    let mut d = Document::new();
+    let story = d.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text("Bent", CharProps::default()))]);
+    let float = |x: f32| Float { wrap: Wrap::InFrontOfText, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x, y: 10.0, ..Default::default() };
+    let shape = |kind, story, extra| InlineObject::Shape {
+        kind,
+        w: 72.0,
+        h: 36.0,
+        fill: None,
+        stroke: Some(Rgb(0, 0, 0)),
+        stroke_width: 1.0,
+        float: float(0.0),
+        story,
+        freeform: None,
+        effects: Default::default(),
+        extra,
+    };
+    let mut warp = TextWarp::new("textArchUp").unwrap();
+    warp.set_adj("adj", 9_000_000);
+    let art = shape(ShapeKind::TextBox, Some(story), ShapeExtra { id: 5, warp: Some(warp), ..Default::default() });
+    let target = shape(ShapeKind::Ellipse, None, ShapeExtra { id: 7, ..Default::default() });
+    let lonely = shape(ShapeKind::Rectangle, None, ShapeExtra { id: 9, ..Default::default() });
+    let link = ShapeExtra { start: Some(ConnEnd { id: 5, site: 3 }), end: Some(ConnEnd { id: 7, site: 2 }), arrow_end: true, ..Default::default() };
+    let mut conn = shape(ShapeKind::ElbowConnector, None, link);
+    if let InlineObject::Shape { float: f, .. } = &mut conn {
+        *f = Float { flip_v: true, ..float(80.0) };
+    }
+    let mut p = Paragraph::with_text("", CharProps::default());
+    for o in [art.clone(), conn.clone(), target.clone(), lonely] {
+        let end = p.len();
+        p.insert_object(end, o, &CharProps::default()).unwrap();
+    }
+    d.body = vec![para_block(p)];
+    let r = rt(&d);
+    let got = &paras(&r)[0].objects;
+    // The glued-to shapes keep their ids, the connector its ends, arrowhead and flip.
+    let extra = |o: &InlineObject| match o {
+        InlineObject::Shape { extra, .. } => extra.clone(),
+        _ => panic!("{o:?}"),
+    };
+    assert_eq!(extra(&got[0]), extra(&art));
+    assert_eq!(extra(&got[1]), extra(&conn));
+    assert!(matches!(&got[1], InlineObject::Shape { kind: ShapeKind::ElbowConnector, float, .. } if float.flip_v));
+    assert_eq!(extra(&got[2]), extra(&target));
+    assert_eq!(extra(&got[3]).id, 0, "nothing is glued to it");
+
+    // Hostile: an unknown warp, a huge adjust value, a glue to a missing shape.
+    let xml = wordcraft_docx::write(&r).unwrap();
+    let mut pkg = zip::ZipArchive::new(std::io::Cursor::new(xml)).unwrap();
+    let mut doc_xml = String::new();
+    std::io::Read::read_to_string(&mut pkg.by_name("word/document.xml").unwrap(), &mut doc_xml).unwrap();
+    let doc_xml = doc_xml
+        .replace("prst=\"textArchUp\"", "prst=\"textNotAWarp\"")
+        .replace("a:stCxn id=\"5\" idx=\"3\"", "a:stCxn id=\"404\" idx=\"99999999999\"");
+    let bytes = replace_part(&wordcraft_docx::write(&r).unwrap(), "word/document.xml", doc_xml.as_bytes());
+    let h = wordcraft_docx::read(&bytes).unwrap();
+    let got = &paras(&h)[0].objects;
+    assert_eq!(extra(&got[0]).warp, None);
+    assert_eq!(extra(&got[1]).start, Some(ConnEnd { id: 404, site: wordcraft_doc::connector::MAX_SITE }));
+}
+
+/// `zip` with part `name` replaced by `data`.
+fn replace_part(zip_bytes: &[u8], name: &str, data: &[u8]) -> Vec<u8> {
+    let mut src = zip::ZipArchive::new(std::io::Cursor::new(zip_bytes)).unwrap();
+    let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    for i in 0..src.len() {
+        let mut f = src.by_index(i).unwrap();
+        let n = f.name().to_string();
+        out.start_file(n.as_str(), zip::write::SimpleFileOptions::default()).unwrap();
+        if n == name {
+            std::io::Write::write_all(&mut out, data).unwrap();
+        } else {
+            std::io::copy(&mut f, &mut out).unwrap();
+        }
+    }
+    out.finish().unwrap().into_inner()
+}
diff --git a/crates/docx/tests/section_text_direction.rs b/crates/docx/tests/section_text_direction.rs
new file mode 100644
index 0000000000..77efbaf56b
--- /dev/null
+++ b/crates/docx/tests/section_text_direction.rs
@@ -0,0 +1,50 @@
+//! Section text direction (`w:textDirection` in `w:sectPr`, ECMA-376 Part 1 §17.6.20). Fixtures
+//! are hand-written from the spec.
+
+use std::io::{Read, Write};
+
+use wordcraft_doc::props::TextDirection;
+
+fn docx(body: &str) -> Vec<u8> {
+    let root = r#"<?xml version="1.0" encoding="UTF-8"?><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>"#;
+    let doc = format!(
+        r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?><w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>{body}</w:body></w:document>"#
+    );
+    let mut zw = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    for (name, bytes) in [("_rels/.rels", root.as_bytes()), ("word/document.xml", doc.as_bytes())] {
+        zw.start_file(name, zip::write::SimpleFileOptions::default()).unwrap();
+        zw.write_all(bytes).unwrap();
+    }
+    zw.finish().unwrap().into_inner()
+}
+
+fn document_xml(bytes: &[u8]) -> String {
+    let mut z = zip::ZipArchive::new(std::io::Cursor::new(bytes)).unwrap();
+    let mut s = String::new();
+    z.by_name("word/document.xml").unwrap().read_to_string(&mut s).unwrap();
+    s
+}
+
+#[test]
+fn section_text_direction_round_trips_in_schema_order() {
+    // Three sections: vertical East Asian (tbRl), bottom-to-top (btLr) and a value no one knows.
+    let sect = |dir: &str| format!(r#"<w:sectPr><w:titlePg/><w:textDirection w:val="{dir}"/><w:bidi/></w:sectPr>"#);
+    let body = format!(
+        r#"<w:p><w:pPr>{}</w:pPr><w:r><w:t>縦書き</w:t></w:r></w:p><w:p><w:pPr>{}</w:pPr><w:r><w:t>Up</w:t></w:r></w:p><w:p><w:r><w:t>Odd</w:t></w:r></w:p>{}"#,
+        sect("tbRl"),
+        sect("btLr"),
+        sect("diagonal")
+    );
+    let d = wordcraft_docx::read(&docx(&body)).unwrap();
+    let dirs: Vec<TextDirection> = d.sections().iter().map(|(_, s)| s.text_direction).collect();
+    assert_eq!(dirs, vec![TextDirection::Down, TextDirection::Up, TextDirection::Horizontal]);
+    let out = wordcraft_docx::write(&d).unwrap();
+    let xml = document_xml(&out);
+    // After w:titlePg and before w:bidi (CT_SectPr's sequence); a horizontal section writes none.
+    assert!(xml.contains(r#"<w:titlePg/><w:textDirection w:val="tbRl"/><w:bidi/>"#), "{xml}");
+    assert!(xml.contains(r#"<w:textDirection w:val="btLr"/>"#));
+    assert_eq!(xml.matches("w:textDirection").count(), 2);
+    let back = wordcraft_docx::read(&out).unwrap();
+    let again: Vec<TextDirection> = back.sections().iter().map(|(_, s)| s.text_direction).collect();
+    assert_eq!(again, dirs);
+}
diff --git a/crates/docx/tests/text_boxes.rs b/crates/docx/tests/text_boxes.rs
index 78fb1ac080..df18ff7ed0 100644
--- a/crates/docx/tests/text_boxes.rs
+++ b/crates/docx/tests/text_boxes.rs
@@ -46,6 +46,7 @@ fn text_box(d: &mut Document, text: &str, body: TextBody) -> InlineObject {
         story: Some(id),
         effects: Default::default(),
         freeform: None,
+        extra: Default::default(),
     }
 }
 
diff --git a/crates/docx/tests/word_xml.rs b/crates/docx/tests/word_xml.rs
new file mode 100644
index 0000000000..1a4287b801
--- /dev/null
+++ b/crates/docx/tests/word_xml.rs
@@ -0,0 +1,215 @@
+//! Word XML files (#548): Flat OPC (Word XML Document) and Word 2003 XML, from hand-written
+//! samples (never files produced by Word).
+
+use base64::Engine as _;
+use wordcraft_doc::props::Align;
+use wordcraft_doc::section::NumFormat;
+use wordcraft_doc::{Block, Document, InlineObject, Paragraph};
+use wordcraft_docx::{DocxError, XmlKind, read_xml, sniff_xml};
+
+fn paras(doc: &Document) -> Vec<&Paragraph> {
+    doc.body.iter().filter_map(|b| b.as_para()).collect()
+}
+
+fn part_text(doc: &Document, id: Option<u32>) -> String {
+    id.and_then(|i| doc.parts.get(&i))
+        .map(|p| p.blocks.iter().filter_map(|b| b.as_para()).map(|p| p.plain_text()).collect::<Vec<_>>().join("\n"))
+        .unwrap_or_default()
+}
+
+fn tiny_png_b64() -> String {
+    let img = image::RgbaImage::from_fn(2, 2, |x, y| image::Rgba([x as u8 * 100, y as u8 * 100, 50, 255]));
+    let mut out = std::io::Cursor::new(Vec::new());
+    img.write_to(&mut out, image::ImageFormat::Png).unwrap();
+    let b64 = base64::engine::general_purpose::STANDARD.encode(out.into_inner());
+    // Line breaks inside base64, as the formats write it.
+    b64.as_bytes().chunks(20).map(|c| std::str::from_utf8(c).unwrap()).collect::<Vec<_>>().join("\n")
+}
+
+/// A minimal Flat OPC package written by hand: namespaces declared on the package element only,
+/// a hyperlink relationship, a picture in base64 and an empty part.
+#[test]
+fn reads_a_hand_written_flat_opc_package() {
+    let png = tiny_png_b64();
+    let xml = format!(
+        r#"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<?mso-application progid="Word.Document"?>
+<pkg:package xmlns:pkg="http://schemas.microsoft.com/office/2006/xmlPackage" xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">
+  <pkg:part pkg:name="/_rels/.rels" pkg:contentType="application/vnd.openxmlformats-package.relationships+xml">
+    <pkg:xmlData>
+      <Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>
+    </pkg:xmlData>
+  </pkg:part>
+  <pkg:part pkg:name="/word/_rels/document.xml.rels" pkg:contentType="application/vnd.openxmlformats-package.relationships+xml">
+    <pkg:xmlData><Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId5" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" Target="https://example.org/flat" TargetMode="External"/><Relationship Id="rId6" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/image" Target="media/dot.png"/></Relationships></pkg:xmlData>
+  </pkg:part>
+  <pkg:part pkg:name="/word/document.xml" pkg:contentType="application/vnd.openxmlformats-officedocument.wordprocessingml.document.main+xml">
+    <pkg:xmlData>
+      <w:document xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships" xmlns:v="urn:schemas-microsoft-com:vml"><w:body>
+        <w:p><w:r><w:rPr><w:b/></w:rPr><w:t>Seed &amp; soil</w:t></w:r></w:p>
+        <w:p><w:hyperlink r:id="rId5"><w:r><w:t>link</w:t></w:r></w:hyperlink></w:p>
+        <w:p><w:r><w:pict><v:shape style="width:24pt;height:12pt"><v:imagedata r:id="rId6"/></v:shape></w:pict></w:r></w:p>
+      </w:body></w:document>
+    </pkg:xmlData>
+  </pkg:part>
+  <pkg:part pkg:name="/word/media/dot.png" pkg:contentType="image/png" pkg:compression="store">
+    <pkg:binaryData>{png}</pkg:binaryData>
+  </pkg:part>
+  <pkg:part pkg:name="/word/empty.xml" pkg:contentType="application/xml"><pkg:xmlData/></pkg:part>
+</pkg:package>"#
+    );
+    assert_eq!(sniff_xml(xml.as_bytes()), XmlKind::FlatOpc);
+    let doc = read_xml(xml.as_bytes()).unwrap();
+    let ps = paras(&doc);
+    assert_eq!(ps[0].plain_text(), "Seed & soil");
+    assert_eq!(ps[0].props_at(0).bold, Some(true));
+    assert_eq!(ps[1].props_at(0).link.as_deref(), Some("https://example.org/flat"));
+    assert!(matches!(ps[2].objects.first(), Some(InlineObject::Image { w, h, .. }) if *w == 24.0 && *h == 12.0));
+    assert_eq!(doc.media.len(), 1);
+}
+
+/// A Word 2003 XML Document, hand-written from the Office 2003 XML Reference Schemas.
+fn wordml_2003_sample() -> String {
+    let png = tiny_png_b64();
+    format!(
+        r##"<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<?mso-application progid="Word.Document"?>
+<w:wordDocument xmlns:w="http://schemas.microsoft.com/office/word/2003/wordml" xmlns:wx="http://schemas.microsoft.com/office/word/2003/auxHint" xmlns:v="urn:schemas-microsoft-com:vml" xmlns:o="urn:schemas-microsoft-com:office:office" xmlns:aml="http://schemas.microsoft.com/aml/2001/core" w:macrosPresent="no">
+  <o:DocumentProperties><o:Title>Garden notes</o:Title><o:Author>Ada Gardener</o:Author><o:Keywords>beans</o:Keywords></o:DocumentProperties>
+  <w:fonts><w:defaultFonts w:ascii="Georgia" w:fareast="Georgia" w:h-ansi="Georgia" w:cs="Georgia"/></w:fonts>
+  <w:lists>
+    <w:listDef w:listDefId="3"><w:plt w:val="HybridMultilevel"/>
+      <w:lvl w:ilvl="0"><w:start w:val="1"/><w:nfc w:val="4"/><w:lvlText w:val="%1)"/><w:lvlJc w:val="left"/><w:pPr><w:ind w:left="720" w:hanging="360"/></w:pPr></w:lvl>
+    </w:listDef>
+    <w:list w:ilfo="2"><w:ilst w:val="3"/></w:list>
+  </w:lists>
+  <w:styles>
+    <w:versionOfBuiltInStyleNames w:val="4"/>
+    <w:style w:type="paragraph" w:default="on" w:styleId="Normal"><w:name w:val="Normal"/><w:rPr><wx:font wx:val="Georgia"/><w:sz w:val="24"/><w:sz-cs w:val="24"/></w:rPr></w:style>
+    <w:style w:type="paragraph" w:styleId="Heading1"><w:name w:val="heading 1"/><wx:uiName wx:val="Heading 1"/><w:basedOn w:val="Normal"/><w:next w:val="Normal"/><w:pPr><w:keepNext/><w:spacing w:before="240" w:after="60"/><w:outlineLvl w:val="0"/></w:pPr><w:rPr><w:b/><w:sz w:val="32"/></w:rPr></w:style>
+  </w:styles>
+  <w:docPr><w:view w:val="print"/><w:zoom w:percent="100"/><w:footnotePr><w:footnote w:type="separator"><w:p><w:r><w:separator/></w:r></w:p></w:footnote></w:footnotePr></w:docPr>
+  <w:body>
+    <wx:sect>
+      <w:p><w:pPr><w:pStyle w:val="Heading1"/></w:pPr><aml:annotation aml:id="0" w:type="Word.Bookmark.Start" w:name="plan"/><aml:annotation aml:id="1" w:type="Word.Comment.Start"/><w:r><w:t>Plan</w:t></w:r><aml:annotation aml:id="1" w:type="Word.Comment.End"/><w:r><aml:annotation aml:id="1" aml:author="Bo" w:initials="B" w:type="Word.Comment"><aml:content><w:p><w:r><w:t>Too short?</w:t></w:r></w:p></aml:content></aml:annotation></w:r><aml:annotation aml:id="0" w:type="Word.Bookmark.End"/></w:p>
+      <w:p><w:pPr><w:jc w:val="center"/><w:ind w:first-line="360"/><w:spacing w:line="360" w:line-rule="auto"/></w:pPr>
+        <w:r><w:t>Plain </w:t></w:r>
+        <w:r><w:rPr><w:rFonts w:ascii="Courier New" w:h-ansi="Courier New"/><w:b/><w:i/><w:u w:val="single"/><w:sz w:val="28"/><w:color w:val="FF0000"/></w:rPr><w:t>loud</w:t></w:r>
+        <w:r><w:tab/><w:t>then</w:t><w:br/><w:t>more</w:t></w:r>
+        <w:r><w:footnote><w:p><w:r><w:footnoteRef/></w:r><w:r><w:t>Sown in May.</w:t></w:r></w:p></w:footnote></w:r>
+      </w:p>
+      <w:p><w:hlink w:dest="https://example.org/beans" w:screenTip="Beans"><w:r><w:rPr><w:rStyle w:val="Hyperlink"/></w:rPr><w:t>bean guide</w:t></w:r></w:hlink></w:p>
+      <w:p><w:pPr><w:listPr><w:ilvl w:val="0"/><w:ilfo w:val="2"/><wx:t wx:val="a)"/></w:listPr></w:pPr><w:r><w:t>Water the beans</w:t></w:r><aml:annotation aml:id="7" aml:author="Ada" aml:createdate="2004-05-01T10:00:00Z" w:type="Word.Insertion"><aml:content><w:r><w:t> daily</w:t></w:r></aml:content></aml:annotation></w:p>
+      <w:tbl>
+        <w:tblPr><w:tblW w:w="0" w:type="auto"/></w:tblPr>
+        <w:tblGrid><w:gridCol w:w="2000"/><w:gridCol w:w="2000"/></w:tblGrid>
+        <w:tr><w:tc><w:tcPr><w:tcW w:w="2000" w:type="dxa"/><w:vmerge w:val="restart"/></w:tcPr><w:p><w:r><w:t>A1</w:t></w:r></w:p></w:tc><w:tc><w:tcPr><w:tcW w:w="2000" w:type="dxa"/></w:tcPr><w:p><w:r><w:t>B1</w:t></w:r></w:p></w:tc></w:tr>
+        <w:tr><w:tc><w:tcPr><w:tcW w:w="2000" w:type="dxa"/><w:vmerge/></w:tcPr><w:p/></w:tc><w:tc><w:tcPr><w:tcW w:w="2000" w:type="dxa"/></w:tcPr><w:p><w:r><w:t>B2</w:t></w:r></w:p></w:tc></w:tr>
+      </w:tbl>
+      <w:p><w:r><w:pict><w:binData w:name="wordml://02000001.png">{png}</w:binData><v:shape id="_x0000_i1025" type="#_x0000_t75" style="width:36pt;height:18pt"><v:imagedata src="wordml://02000001.png" o:title="dot"/></v:shape></w:pict></w:r></w:p>
+      <w:sectPr>
+        <w:hdr w:type="odd"><w:p><w:r><w:t>Garden header</w:t></w:r></w:p></w:hdr>
+        <w:pgSz w:w="12240" w:h="15840"/><w:pgMar w:top="1440" w:right="1800" w:bottom="1440" w:left="1800" w:header="720" w:footer="720" w:gutter="0"/>
+      </w:sectPr>
+    </wx:sect>
+  </w:body>
+</w:wordDocument>"##
+    )
+}
+
+#[test]
+fn imports_word_2003_xml() {
+    let xml = wordml_2003_sample();
+    assert_eq!(sniff_xml(xml.as_bytes()), XmlKind::WordMl2003);
+    let doc = read_xml(xml.as_bytes()).unwrap();
+    assert_eq!(doc.core.title, "Garden notes");
+    assert_eq!(doc.core.creator, "Ada Gardener");
+
+    let h1 = doc.styles.get("Heading1").expect("Heading1 style");
+    assert_eq!(h1.chr.bold, Some(true));
+    assert_eq!(h1.chr.size, Some(16.0));
+
+    let ps = paras(&doc);
+    assert_eq!(ps[0].plain_text(), "Plan");
+    assert_eq!(ps[0].props.style.as_deref(), Some("Heading1"));
+    assert!(ps[0].objects.iter().any(|o| matches!(o, InlineObject::BookmarkStart { name, .. } if name == "plan")));
+
+    let p = ps[1];
+    assert_eq!(p.props.align, Some(Align::Center));
+    assert_eq!(p.props.indent_first, Some(18.0));
+    let loud = p.text.find("loud").unwrap();
+    let c = p.props_of_char(loud);
+    assert_eq!((c.bold, c.italic, c.size, c.font.as_deref()), (Some(true), Some(true), Some(14.0), Some("Courier New")));
+    assert!(c.underline.is_some() && c.color.is_some());
+    assert!(p.plain_text().contains("Plain loud\tthen"));
+    let note = p.objects.iter().find_map(|o| match o {
+        InlineObject::NoteRef { id, .. } => Some(*id),
+        _ => None,
+    });
+    assert_eq!(part_text(&doc, note), "Sown in May.");
+
+    assert_eq!(ps[2].props_at(0).link.as_deref(), Some("https://example.org/beans"));
+    let listed = ps[3];
+    let num = listed.props.numbering.expect("list paragraph");
+    let lvl = doc.numbering.level(num.num, num.level).expect("list level");
+    assert_eq!((lvl.format, lvl.text.as_str(), lvl.indent), (NumFormat::LowerLetter, "%1)", 36.0));
+    let ins = listed.props_of_char(listed.text.find("daily").unwrap()).ins.and_then(|i| doc.revisions.get(i as usize));
+    assert_eq!(ins.map(|r| r.author.as_str()), Some("Ada"));
+    let comment = doc.comments.values().next().expect("comment");
+    assert_eq!((comment.author.as_str(), part_text(&doc, Some(comment.part)).as_str()), ("Bo", "Too short?"));
+
+    let table = doc.body.iter().find_map(|b| match b.as_ref() {
+        Block::Table(t) => Some(t),
+        _ => None,
+    });
+    let table = table.expect("table");
+    assert_eq!(table.rows.len(), 2);
+    assert_eq!(table.rows[0].cells[1].blocks.first().and_then(|b| b.as_para()).map(|p| p.plain_text()).as_deref(), Some("B1"));
+
+    let pic = ps.iter().flat_map(|p| p.objects.iter()).find(|o| matches!(o, InlineObject::Image { .. }));
+    assert!(matches!(pic, Some(InlineObject::Image { w, h, .. }) if *w == 36.0 && *h == 18.0));
+    assert_eq!(doc.media.len(), 1);
+
+    assert_eq!(doc.last_section.page_w, 612.0);
+    assert_eq!(doc.last_section.margin_left, 90.0);
+    assert_eq!(part_text(&doc, doc.last_section.headers.default), "Garden header");
+}
+
+#[test]
+fn hostile_word_xml_is_an_error_not_a_panic() {
+    let flat = r#"<pkg:package xmlns:pkg="http://schemas.microsoft.com/office/2006/xmlPackage">"#;
+    let w2003 = r#"<w:wordDocument xmlns:w="http://schemas.microsoft.com/office/word/2003/wordml">"#;
+    // Other XML (and non-XML) is refused with the Word XML error.
+    for other in ["<html><body>hi</body></html>", "", "not xml at all", "<package/>"] {
+        assert_eq!(read_xml(other.as_bytes()), Err(DocxError::NotWordXml), "{other:?}");
+    }
+    // Broken packages: errors.
+    for bad in [
+        flat.to_string(),
+        format!("{flat}</pkg:package>"),
+        format!("{flat}<pkg:part pkg:name=\"/word/document.xml\"><pkg:binaryData>!!!not base64</pkg:binaryData></pkg:part></pkg:package>"),
+        format!("{flat}<pkg:part pkg:name=\"/word/document.xml\"><pkg:xmlData><w:document></pkg:xmlData></pkg:part></pkg:package>"),
+    ] {
+        assert!(read_xml(bad.as_bytes()).is_err(), "{bad}");
+    }
+    // Lenient leftovers never panic.
+    for odd in [
+        format!("{flat}<pkg:part/><pkg:part pkg:name=\"\"><pkg:xmlData/></pkg:part><x/></pkg:package>"),
+        format!(
+            "{w2003}<w:body><w:p><w:r><w:footnote w:type=\"separator\"/><w:pict><w:binData w:name=\"a\">%%%</w:binData><v:imagedata src=\"a\"/></w:pict></w:r></w:p></w:body></w:wordDocument>"
+        ),
+        format!(
+            "{w2003}<w:lists><w:list/><w:listDef/></w:lists><w:body><aml:annotation xmlns:aml=\"http://schemas.microsoft.com/aml/2001/core\" aml:id=\"x\" w:type=\"Word.Comment\"/><w:sectPr><w:hdr/><w:ftr w:type=\"first\"/></w:sectPr></w:body></w:wordDocument>"
+        ),
+        format!("{w2003}{}", "<w:p>".repeat(5000)),
+    ] {
+        let _ = read_xml(odd.as_bytes());
+    }
+    // Too many parts.
+    let mut many = String::from(flat);
+    for i in 0..20_001 {
+        many.push_str(&format!("<pkg:part pkg:name=\"/p{i}.bin\"><pkg:binaryData>AA==</pkg:binaryData></pkg:part>"));
+    }
+    many.push_str("</pkg:package>");
+    assert!(matches!(read_xml(many.as_bytes()), Err(DocxError::Limit(_))));
+}
diff --git a/crates/engine/src/catalog.rs b/crates/engine/src/catalog.rs
index 196b65081f..92d2cdf982 100644
--- a/crates/engine/src/catalog.rs
+++ b/crates/engine/src/catalog.rs
@@ -13,6 +13,7 @@ File|Backstage|Open|file.open
 File|Backstage|Save|file.save
 File|Backstage|Save As|file.saveAs
 File|Backstage|Print|file.print
+File|Backstage|Print Markup|file.printMarkup
 File|Backstage|Close|file.close
 File|Backstage|Info|file.info
 File|Backstage|Properties|file.properties
@@ -57,6 +58,7 @@ Home|Font|Subscript|format.subscript
 Home|Font|Superscript|format.superscript
 Home|Font|Text Effects Outline|format.outline
 Home|Font|Text Effects Shadow|format.shadow
+Home|Font|Text Effects and Typography|format.textEffects
 Home|Font|Text Highlight Color|format.highlight
 Home|Font|Font Color|format.color
 Home|Font|Character Shading|format.shading
@@ -219,6 +221,7 @@ Layout|Page Setup|Page Setup Dialog|layout.pageSetup
 Layout|Page Setup|Vertical Alignment|layout.verticalAlign
 Layout|Page Setup|Document Grid|layout.documentGrid
 Layout|Page Setup|Section Direction|layout.sectionRtl
+Layout|Page Setup|Text Direction|layout.textDirection
 Layout|Paragraph|Indent|para.indents
 Layout|Paragraph|Spacing|para.spacing
 Layout|Arrange|Position|arrange.position
@@ -252,6 +255,7 @@ References|Index|Insert Index|references.index
 References|Index|Update Index|references.updateIndex
 References|Table of Authorities|Mark Citation|references.markCitation
 References|Table of Authorities|Insert Table of Authorities|references.tableOfAuthorities
+References|Table of Authorities|Update Table|references.updateAuthorities
 References|Fields|Update Fields|references.updateFields
 Mailings|Create|Envelopes|mailings.envelopes
 Mailings|Create|Labels|mailings.labels
@@ -275,6 +279,7 @@ Review|Proofing|Thesaurus|review.thesaurus
 Review|Proofing|Word Count|review.wordCount
 Review|Speech|Read Aloud|review.readAloud
 Review|Accessibility|Check Accessibility|file.accessibility
+Review|Accessibility|Alt Text|view.altTextPane
 Review|Language|Translate|review.translate
 Review|Language|Language|review.language
 Review|Comments|New Comment|review.newComment
@@ -329,6 +334,17 @@ View|Window|Switch Windows|view.switchWindows
 View|Macros|Macros|tools.macros
 View|Macros|Record Macro|tools.recordMacro
 View|SharePoint|Properties|file.properties
+Developer|Controls|Rich Text Content Control|developer.richText
+Developer|Controls|Plain Text Content Control|developer.plainText
+Developer|Controls|Picture Content Control|developer.picture
+Developer|Controls|Building Block Gallery Content Control|developer.buildingBlock
+Developer|Controls|Check Box Content Control|developer.checkBox
+Developer|Controls|Combo Box Content Control|developer.comboBox
+Developer|Controls|Drop-Down List Content Control|developer.dropDown
+Developer|Controls|Date Picker Content Control|developer.datePicker
+Developer|Controls|Repeating Section Content Control|developer.repeatingSection
+Developer|Controls|Design Mode|developer.designMode
+Developer|Controls|Properties|developer.properties
 Table Design|Table Style Options|Table Style Options|table.look
 Table Design|Table Styles|Table Styles|table.style
 Table Design|Table Styles|New Table Style|table.newStyle
@@ -342,6 +358,7 @@ Table Layout|Table|Select Row|table.selectRow
 Table Layout|Table|Select Cell|table.selectCell
 Table Layout|Table|View Gridlines|table.viewGridlines
 Table Layout|Table|Properties|table.properties
+Table Layout|Table|Alt Text|table.altText
 Table Layout|Table|Table Direction|table.rtl
 Table Layout|Draw|Draw Table|table.draw
 Table Layout|Draw|Eraser|table.eraser
@@ -390,6 +407,19 @@ Equation|Equation Options|Change to Inline / Display|equation.display
 Equation|Equation Options|Justification|equation.justify
 Equation|Equation Options|Equation Number (#)|equation.number
 Equation|Equation Options|Structure Commands|equation.structure
+Outlining|Outline Tools|Promote to Heading 1|outline.promoteToHeading1
+Outlining|Outline Tools|Promote|outline.promote
+Outlining|Outline Tools|Outline Level|outline.level
+Outlining|Outline Tools|Demote|outline.demote
+Outlining|Outline Tools|Demote to Body Text|outline.demoteToBody
+Outlining|Outline Tools|Move Up|outline.moveUp
+Outlining|Outline Tools|Move Down|outline.moveDown
+Outlining|Outline Tools|Expand|outline.expand
+Outlining|Outline Tools|Collapse|outline.collapse
+Outlining|Outline Tools|Show Level|outline.showLevel
+Outlining|Outline Tools|Show Text Formatting|outline.showFormatting
+Outlining|Outline Tools|Show First Line Only|outline.firstLineOnly
+Outlining|Close|Close Outline View|outline.close
 Picture Format|Adjust|Remove Background|picture.removeBackground
 Picture Format|Adjust|Corrections|picture.corrections
 Picture Format|Adjust|Color|picture.color
@@ -401,12 +431,29 @@ Picture Format|Adjust|Reset Picture|picture.reset
 Picture Format|Picture Styles|Picture Styles|picture.style
 Picture Format|Picture Styles|Picture Border|picture.border
 Picture Format|Accessibility|Alt Text|picture.altText
+Shape Format|Accessibility|Alt Text|object.altText
 Picture Format|Size|Crop|picture.crop
 Picture Format|Size|Size|picture.size
 Picture Format|Size|Rotation|arrange.rotation
+SmartArt Design|Create Graphic|Add Shape|smartArt.addShape
+SmartArt Design|Create Graphic|Promote|smartArt.promote
+SmartArt Design|Create Graphic|Demote|smartArt.demote
+SmartArt Design|Create Graphic|Text Pane|smartArt.textPane
+SmartArt Design|Layouts|Layouts|smartArt.layout
+SmartArt Design|SmartArt Styles|Change Colors|smartArt.colors
+SmartArt Design|Reset|Reset Graphic|smartArt.reset
+Chart Design|Type|Change Chart Type|chart.type
+Chart Design|Data|Edit Data|chart.editData
+Chart Design|Chart Layouts|Chart Title|chart.title
+Chart Design|Chart Layouts|Legend|chart.legend
+Chart Design|Chart Layouts|Data Labels|chart.dataLabels
 Shape Format|Shape Styles|Shape Fill|shape.fill
 Shape Format|Shape Styles|Shape Outline|shape.outline
 Shape Format|Shape Styles|Shape Effects|shape.effects
+Shape Format|WordArt Styles|WordArt Quick Styles|wordArt.style
+Shape Format|WordArt Styles|Text Fill|wordArt.textFill
+Shape Format|WordArt Styles|Text Outline|wordArt.textOutline
+Shape Format|WordArt Styles|Text Effects Transform|wordArt.transform
 Shape Format|Text|Text Direction|shape.textDirection
 Shape Format|Text|Align Text|shape.alignText
 Shape Format|Text|Create Link|shape.link
diff --git a/crates/engine/src/cmd/accessibility.rs b/crates/engine/src/cmd/accessibility.rs
new file mode 100644
index 0000000000..c6044e48af
--- /dev/null
+++ b/crates/engine/src/cmd/accessibility.rs
@@ -0,0 +1,321 @@
+//! The accessibility checker (Review › Check Accessibility): what makes the body hard to use with
+//! a screen reader or hard to read, as `{"kind": "error|warning|tip", "rule", "issue", "where",
+//! "pos"?, "select"?, "fix"?, "action"?}` items.
+//!
+//! `where` is the paragraph (or table) path; `pos` a place to put the caret there; `select` the
+//! range that selects the object an issue is about; `action` a command (`{"label", "command",
+//! "params"}`) that fixes it, run with the caret at `pos` (or the object selected). The rules and
+//! their wording are our own; the contrast rule uses the WCAG 2 contrast ratio.
+
+use serde_json::{Value, json};
+use wordcraft_doc::para::{InlineObject, OBJ};
+use wordcraft_doc::props::{Rgb, TextColor, VMerge};
+use wordcraft_doc::table::Table;
+use wordcraft_doc::{Block, Document, Paragraph, Path, Pos, StoryRef};
+
+/// Most issues reported (a hostile document can't make the report huge).
+const MAX_ISSUES: usize = 500;
+/// This many empty paragraphs in a row look like spacing made with Enter.
+const BLANK_RUN: usize = 3;
+
+/// The checker's findings for `doc`, errors first, then warnings, then tips (each in document order).
+pub fn check(doc: &Document) -> Vec<Value> {
+    let mut c = Checker { doc, issues: Vec::new() };
+    c.run();
+    let rank = |v: &Value| match v["kind"].as_str() {
+        Some("error") => 0,
+        Some("warning") => 1,
+        _ => 2,
+    };
+    c.issues.sort_by_key(rank);
+    c.issues.truncate(MAX_ISSUES);
+    c.issues
+}
+
+struct Checker<'a> {
+    doc: &'a Document,
+    issues: Vec<Value>,
+}
+
+fn at(path: &Path, off: usize) -> Pos {
+    Pos { story: StoryRef::Body, path: path.clone(), off }
+}
+
+impl Checker<'_> {
+    fn push(&mut self, v: Value) {
+        if self.issues.len() < MAX_ISSUES * 2 {
+            self.issues.push(v);
+        }
+    }
+
+    fn run(&mut self) {
+        let doc = self.doc;
+        let mut last_level: Option<u8> = None;
+        let mut tables: Vec<Path> = Vec::new();
+        let mut blank: Vec<Path> = Vec::new();
+        for path in doc.para_paths(StoryRef::Body) {
+            let Some(p) = doc.para(StoryRef::Body, &path) else { continue };
+            if let Some((tp, _, _)) = path.cell()
+                && !tables.contains(&tp)
+            {
+                tables.push(tp);
+            }
+            self.objects(&path, p);
+            // Empty paragraphs in a row (top level, no section break): spacing made with Enter.
+            let consecutive = blank.last().is_none_or(|b| b.0.len() == 1 && path.0.len() == 1 && b.last() + 1 == path.last());
+            if path.0.len() == 1 && p.text.trim().is_empty() && p.section.is_none() && consecutive {
+                blank.push(path.clone());
+            } else {
+                self.blank_run(&blank);
+                blank.clear();
+                if path.0.len() == 1 && p.text.trim().is_empty() && p.section.is_none() {
+                    blank.push(path.clone());
+                }
+            }
+            let rp = doc.styles.resolve_para(&p.props);
+            if let Some(l) = rp.outline_level.filter(|_| !p.plain_text().trim().is_empty()) {
+                if let Some(prev) = last_level
+                    && l > prev + 1
+                {
+                    self.push(json!({"kind": "warning", "rule": "headingOrder", "issue": format!("Heading level skipped (Heading {} after Heading {})", l + 1, prev + 1), "where": path.0, "pos": at(&path, 0), "fix": "Use the next heading level down, so the outline has no gaps"}));
+                }
+                last_level = Some(l);
+            }
+            if p.runs.iter().any(|r| r.props.link.is_some()) {
+                let txt = p.plain_text().to_lowercase();
+                if txt.contains("click here") {
+                    self.push(json!({"kind": "tip", "rule": "linkText", "issue": "Link text \"click here\" isn't descriptive", "where": path.0, "pos": at(&path, 0)}));
+                }
+            }
+            self.contrast(&path, p, rp.shading);
+        }
+        self.blank_run(&blank);
+        for tp in tables {
+            if let Some(t) = doc.table(StoryRef::Body, &tp) {
+                self.table(&tp, t);
+            }
+        }
+        if doc.core.title.trim().is_empty() {
+            self.push(json!({"kind": "tip", "rule": "docTitle", "issue": "Document has no title", "fix": "file.properties {title}"}));
+        }
+    }
+
+    fn blank_run(&mut self, blank: &[Path]) {
+        if blank.len() >= BLANK_RUN
+            && let Some(first) = blank.first()
+        {
+            self.push(json!({"kind": "tip", "rule": "blankParagraphs", "issue": format!("{} empty paragraphs in a row", blank.len()), "where": first.0, "pos": at(first, 0), "fix": "Use Space Before/After (Layout › Paragraph) or a page break instead of empty paragraphs"}));
+        }
+    }
+
+    /// Alt text and reading order of the drawings in paragraph `p`.
+    fn objects(&mut self, path: &Path, p: &Paragraph) {
+        for off in p.object_offsets() {
+            let Some(o) = p.object_at(off).filter(|o| o.is_drawing()) else { continue };
+            let pos = at(path, off);
+            let select = json!({"anchor": pos, "focus": at(path, off + OBJ.len_utf8())});
+            // Ink: every stroke is its own object, so asking about each would bury the report.
+            if o.is_decorative() || o.ink().is_some() {
+                continue;
+            }
+            let titled = o.frame().is_some_and(|(_, _, f)| !f.alt.title.trim().is_empty());
+            let described = !o.alt_text().trim().is_empty() || titled;
+            if !described && !self.speaks_for_itself(o) {
+                let (rule, issue) = match o {
+                    InlineObject::Graphic { .. } => ("altText", "Chart or diagram has no alternative text"),
+                    _ => ("altText", "Missing alternative text"),
+                };
+                self.push(json!({
+                    "kind": "error", "rule": rule, "issue": issue, "what": kind_of(o), "where": path.0, "pos": pos, "select": select,
+                    "fix": "Describe it in the Alt Text pane (object.altText), or mark it decorative",
+                    "action": {"label": "Mark as decorative", "command": "object.altText", "params": {"decorative": true}},
+                }));
+            }
+            if o.is_floating() {
+                let mut v = json!({"kind": "tip", "rule": "floating", "issue": "Object isn't in line with text, so its reading order is unclear", "what": kind_of(o), "where": path.0, "pos": pos, "select": select, "fix": "Place it in line with text (Layout › Wrap Text)"});
+                // Charts and diagrams keep their imported placement (see objects.rs).
+                if !matches!(o, InlineObject::Graphic { .. }) {
+                    v["action"] = json!({"label": "In Line with Text", "command": "arrange.wrap", "params": {"wrap": "inline"}});
+                }
+                self.push(v);
+            }
+        }
+    }
+
+    /// A text box with text in it is read out as that text.
+    fn speaks_for_itself(&self, o: &InlineObject) -> bool {
+        o.text_box().and_then(|id| self.doc.parts.get(&id)).is_some_and(|part| {
+            part.blocks.iter().any(|b| match &**b {
+                Block::Para(p) => !p.plain_text().trim().is_empty(),
+                _ => true,
+            })
+        })
+    }
+
+    /// Text whose colour is too close to what it's drawn on (WCAG 2: 4.5:1, 3:1 for large text).
+    fn contrast(&mut self, path: &Path, p: &Paragraph, para_shading: Option<Rgb>) {
+        let doc = self.doc;
+        let cell = path.cell().and_then(|(tp, r, c)| {
+            let t = doc.table(StoryRef::Body, &tp)?;
+            t.rows.get(r).and_then(|row| row.cells.get(c)).and_then(|c| c.props.shading).or(t.props.shading)
+        });
+        let page = doc.settings.page_color.unwrap_or(Rgb::WHITE);
+        let mut start = 0usize;
+        for r in &p.runs {
+            let text = p.text.get(start..start.saturating_add(r.len)).unwrap_or("");
+            start = start.saturating_add(r.len);
+            if text.trim().is_empty() || r.props.hidden == Some(true) {
+                continue;
+            }
+            let rc = doc.styles.resolve_char(p.props.style.as_deref(), &r.props);
+            let TextColor::Rgb(fg) = rc.color else { continue };
+            let bg = rc.highlight.or(rc.shading).or(para_shading).or(cell).unwrap_or(page);
+            let ratio = contrast_ratio(fg, bg);
+            let large = rc.size >= 18.0 || (rc.bold && rc.size >= 14.0);
+            let need = if large { 3.0 } else { 4.5 };
+            if ratio < need {
+                let kind = if ratio < 3.0 { "warning" } else { "tip" };
+                self.push(json!({"kind": kind, "rule": "contrast", "issue": format!("Text is hard to read: contrast {:.1}:1, {need}:1 needed", ratio), "where": path.0, "pos": at(path, 0), "fix": "Use a darker or lighter text colour, or change the shading behind it"}));
+                return;
+            }
+        }
+    }
+
+    fn table(&mut self, tp: &Path, t: &Table) {
+        let cell_pos = |r: usize, c: usize| {
+            let mut v = tp.0.clone();
+            v.extend([r as u32, c as u32, 0]);
+            at(&Path(v), 0)
+        };
+        if t.props.caption.as_deref().is_none_or(|s| s.trim().is_empty()) && t.props.description.as_deref().is_none_or(|s| s.trim().is_empty()) {
+            self.push(json!({"kind": "warning", "rule": "tableAltText", "issue": "Table has no alternative text", "where": tp.0, "pos": cell_pos(0, 0), "fix": "Give it a title or description (table.altText)"}));
+        }
+        if t.rows.len() >= 2 && !t.rows.first().is_some_and(|r| r.props.header) {
+            self.push(json!({
+                "kind": "warning", "rule": "tableHeader", "issue": "Table has no header row", "where": tp.0, "pos": cell_pos(0, 0),
+                "fix": "Repeat the first row as a header row (table.repeatHeader)",
+                "action": {"label": "Repeat Header Rows", "command": "table.repeatHeader", "params": {"value": true}},
+            }));
+        }
+        let empty = |c: &wordcraft_doc::table::Cell| {
+            c.blocks.iter().all(|b| match &**b {
+                Block::Para(p) => p.text.trim().is_empty(),
+                _ => false,
+            })
+        };
+        // A table with nothing in it yet is being filled in, not used for spacing.
+        let filled = !t.rows.iter().flat_map(|r| &r.cells).all(empty);
+        if t.rows.len() >= 2 && filled {
+            for (r, row) in t.rows.iter().enumerate() {
+                if !row.cells.is_empty() && row.cells.iter().all(empty) {
+                    self.push(json!({"kind": "warning", "rule": "blankRow", "issue": format!("Row {} of a table is empty: it looks like spacing", r + 1), "where": tp.0, "pos": cell_pos(r, 0), "fix": "Delete the row and use cell margins or spacing instead"}));
+                }
+            }
+        }
+        let cols = t.rows.iter().map(|r| r.cells.len()).max().unwrap_or(0);
+        if cols >= 2 && t.rows.len() >= 2 && filled {
+            for c in 0..cols.min(63) {
+                if t.rows.iter().all(|row| row.cells.get(c).is_none_or(empty)) {
+                    self.push(json!({"kind": "warning", "rule": "blankColumn", "issue": format!("Column {} of a table is empty: it looks like spacing", c + 1), "where": tp.0, "pos": cell_pos(0, c), "fix": "Delete the column and use cell margins instead"}));
+                }
+            }
+        }
+        if t.rows.iter().flat_map(|r| &r.cells).any(|c| c.span() > 1 || c.props.vmerge != VMerge::None) {
+            self.push(json!({"kind": "tip", "rule": "mergedCells", "issue": "Table has merged cells, which screen readers can lose track of", "where": tp.0, "pos": cell_pos(0, 0), "fix": "Split the merged cells (Table Layout › Merge)"}));
+        }
+    }
+}
+
+fn kind_of(o: &InlineObject) -> &'static str {
+    match o {
+        InlineObject::Image { ole: Some(_), .. } => "object",
+        InlineObject::Image { .. } => "picture",
+        InlineObject::Graphic { .. } => "chart",
+        InlineObject::Shape { story: Some(_), .. } => "textBox",
+        InlineObject::Shape { .. } => "shape",
+        InlineObject::Group { .. } => "group",
+        _ => "object",
+    }
+}
+
+/// WCAG 2 relative luminance of an sRGB colour.
+fn luminance(c: Rgb) -> f64 {
+    let ch = |v: u8| {
+        let s = v as f64 / 255.0;
+        if s <= 0.04045 { s / 12.92 } else { ((s + 0.055) / 1.055).powf(2.4) }
+    };
+    0.2126 * ch(c.0) + 0.7152 * ch(c.1) + 0.0722 * ch(c.2)
+}
+
+/// WCAG 2 contrast ratio of two colours, 1 to 21.
+pub fn contrast_ratio(a: Rgb, b: Rgb) -> f64 {
+    let (la, lb) = (luminance(a), luminance(b));
+    let (hi, lo) = if la >= lb { (la, lb) } else { (lb, la) };
+    (hi + 0.05) / (lo + 0.05)
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+    use wordcraft_doc::Document;
+    use wordcraft_doc::props::Rgb;
+
+    use crate::Session;
+
+    fn rules(s: &mut Session) -> Vec<(String, String)> {
+        let v = s.run("file.accessibility", &json!({})).unwrap();
+        v["issues"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|i| (i["kind"].as_str().unwrap().to_string(), i["rule"].as_str().unwrap_or("").to_string()))
+            .collect()
+    }
+
+    #[test]
+    fn contrast_ratio_matches_wcag() {
+        assert!((super::contrast_ratio(Rgb::BLACK, Rgb::WHITE) - 21.0).abs() < 0.01);
+        assert!((super::contrast_ratio(Rgb(0x77, 0x77, 0x77), Rgb::WHITE) - 4.48).abs() < 0.01);
+    }
+
+    #[test]
+    fn shapes_need_alt_text_unless_decorative_and_the_fix_marks_them() {
+        let mut s = Session::new(Document::from_text("Title"));
+        s.doc.core.title = "T".into();
+        s.run("insert.shape", &json!({"kind": "ellipse"})).unwrap();
+        assert!(rules(&mut s).contains(&("error".into(), "altText".into())));
+        // The issue says how to fix it: select the object, run the action.
+        let v = s.run("file.accessibility", &json!({})).unwrap();
+        let i = v["issues"].as_array().unwrap().iter().find(|i| i["rule"] == "altText").unwrap().clone();
+        s.run("select.range", &i["select"]).unwrap();
+        s.run(i["action"]["command"].as_str().unwrap(), &i["action"]["params"]).unwrap();
+        assert!(!rules(&mut s).iter().any(|(_, r)| r == "altText"));
+    }
+
+    #[test]
+    fn tables_blank_paragraphs_and_contrast_are_reported() {
+        let mut s = Session::new(Document::from_text("Intro"));
+        s.doc.core.title = "T".into();
+        // Light grey text on white.
+        s.run("select.all", &json!({})).unwrap();
+        s.run("format.color", &json!({"color": "BBBBBB"})).unwrap();
+        s.run("caret.docEnd", &json!({})).unwrap();
+        for _ in 0..4 {
+            s.run("text.newParagraph", &json!({})).unwrap();
+        }
+        s.run("insert.table", &json!({"rows": 3, "cols": 2})).unwrap();
+        s.run("text.insert", &json!({"text": "Year"})).unwrap();
+        let r = rules(&mut s);
+        for want in
+            [("warning", "contrast"), ("tip", "blankParagraphs"), ("warning", "tableHeader"), ("warning", "tableAltText"), ("warning", "blankRow")]
+        {
+            assert!(r.contains(&(want.0.into(), want.1.into())), "{want:?} in {r:?}");
+        }
+        // Fix the header row from the issue's action, with the caret where it says.
+        let v = s.run("file.accessibility", &json!({})).unwrap();
+        let i = v["issues"].as_array().unwrap().iter().find(|i| i["rule"] == "tableHeader").unwrap().clone();
+        s.run("caret.set", &json!({"pos": i["pos"]})).unwrap();
+        s.run(i["action"]["command"].as_str().unwrap(), &i["action"]["params"]).unwrap();
+        assert!(!rules(&mut s).iter().any(|(_, r)| r == "tableHeader"));
+    }
+}
diff --git a/crates/engine/src/cmd/caret.rs b/crates/engine/src/cmd/caret.rs
index 509afe820a..930372d2a4 100644
--- a/crates/engine/src/cmd/caret.rs
+++ b/crates/engine/src/cmd/caret.rs
@@ -48,6 +48,9 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("select.word", "Select Word", "Navigation", select_word).pure(),
         CommandSpec::new("select.sentence", "Select Sentence", "Navigation", select_sentence).pure(),
         CommandSpec::new("select.paragraph", "Select Paragraph", "Navigation", select_paragraph).pure(),
+        CommandSpec::new("select.dragUnit", "Extend Selection by Units", "Navigation", drag_unit)
+            .params(r#"{"unit": "word|sentence|paragraph", "start": Pos, "end": Pos, "pos": Pos}"#)
+            .pure(),
         CommandSpec::new("select.line", "Select Line", "Navigation", select_line).pure(),
         CommandSpec::new("select.text", "Select Text", "Navigation", select_text).params(r#"{"text": string, "occurrence"?: n}"#).pure(),
         CommandSpec::new("select.collapse", "Collapse Selection", "Navigation", |s, v| {
@@ -287,33 +290,83 @@ fn select_range(s: &mut Session, v: &Value) -> CmdResult {
     sel_result(s)
 }
 
-fn select_word(s: &mut Session, _: &Value) -> CmdResult {
+/// A unit a selection grows by: what a double-click (word), Ctrl/⌘+click (sentence) or
+/// triple-click (paragraph) selects, and what dragging after it extends by.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Unit {
+    Word,
+    Sentence,
+    Paragraph,
+}
+
+impl Unit {
+    pub fn parse(s: &str) -> Option<Unit> {
+        match s {
+            "word" => Some(Unit::Word),
+            "sentence" => Some(Unit::Sentence),
+            "paragraph" => Some(Unit::Paragraph),
+            _ => None,
+        }
+    }
+}
+
+/// The word, sentence or paragraph around `at`, as (start, end). A paragraph includes its mark
+/// (it ends at the start of the next paragraph in the same container, when there is one).
+pub fn unit_range(s: &Session, at: &Pos, unit: Unit) -> (Pos, Pos) {
+    let Some(p) = s.doc.para_at(at) else { return (at.clone(), at.clone()) };
+    let (a, b) = match unit {
+        Unit::Word => p.word_at(at.off),
+        Unit::Sentence => p.sentence_at(at.off),
+        Unit::Paragraph => {
+            let start = Pos { off: 0, ..at.clone() };
+            let end = match s.doc.next_para(at.story, &at.path) {
+                Some(q) if q.parent() == at.path.parent() => Pos { story: at.story, path: q, off: 0 },
+                _ => Pos { off: p.len(), ..at.clone() },
+            };
+            return (start, end);
+        }
+    };
+    (Pos { off: a, ..at.clone() }, Pos { off: b, ..at.clone() })
+}
+
+fn select_unit(s: &mut Session, unit: Unit) -> CmdResult {
     let f = s.sel.focus.clone();
-    if let Some(p) = s.doc.para_at(&f) {
-        let (a, b) = p.word_at(f.off);
-        s.sel = Selection { anchor: Pos { off: a, ..f.clone() }, focus: Pos { off: b, ..f } };
+    if s.doc.para_at(&f).is_some() {
+        let (a, b) = unit_range(s, &f, unit);
+        s.sel = Selection { anchor: a, focus: b };
     }
     sel_result(s)
 }
 
+fn select_word(s: &mut Session, _: &Value) -> CmdResult {
+    select_unit(s, Unit::Word)
+}
+
 fn select_sentence(s: &mut Session, _: &Value) -> CmdResult {
-    let f = s.sel.focus.clone();
-    if let Some(p) = s.doc.para_at(&f) {
-        let (a, b) = p.sentence_at(f.off);
-        s.sel = Selection { anchor: Pos { off: a, ..f.clone() }, focus: Pos { off: b, ..f } };
-    }
-    sel_result(s)
+    select_unit(s, Unit::Sentence)
 }
 
 fn select_paragraph(s: &mut Session, _: &Value) -> CmdResult {
-    let f = s.sel.focus.clone();
-    let len = s.doc.para_at(&f).map(|p| p.len()).unwrap_or(0);
-    // Word includes the paragraph mark: extend to the start of the next paragraph when there is one.
-    let end = match s.doc.next_para(f.story, &f.path) {
-        Some(q) if q.parent() == f.path.parent() => Pos { story: f.story, path: q, off: 0 },
-        _ => Pos { off: len, ..f.clone() },
-    };
-    s.sel = Selection { anchor: Pos { off: 0, ..f }, focus: end };
+    select_unit(s, Unit::Paragraph)
+}
+
+/// Drag after a double-click (words), triple-click (paragraphs) or Ctrl/⌘+click (sentences):
+/// the selection keeps the unit first selected (`start`..`end`) and grows by whole units to
+/// the one under `pos`. Dragging forward anchors at the unit's start; dragging back before it
+/// anchors at its end, as in Word.
+fn drag_unit(s: &mut Session, v: &Value) -> CmdResult {
+    let unit = p::str(v, "unit").and_then(Unit::parse).ok_or_else(|| CmdError::Params("`unit` must be word, sentence or paragraph".into()))?;
+    let get = |k: &str| v.get(k).and_then(parse_pos).ok_or_else(|| CmdError::Params(format!("bad `{k}`")));
+    let (at, start, end) = (s.doc.clamp(&get("pos")?), s.doc.clamp(&get("start")?), s.doc.clamp(&get("end")?));
+    let (start, end) = if start <= end { (start, end) } else { (end, start) };
+    // Only within one story (the pointer over another story keeps the selection).
+    if at.story != start.story || end.story != start.story {
+        return sel_result(s);
+    }
+    let (us, ue) = unit_range(s, &at, unit);
+    s.sel = if at >= start { Selection { focus: ue.max(end.clone()), anchor: start } } else { Selection { focus: us.min(start), anchor: end } };
+    s.goal_x = None;
+    s.pending = None;
     sel_result(s)
 }
 
diff --git a/crates/engine/src/cmd/chart.rs b/crates/engine/src/cmd/chart.rs
new file mode 100644
index 0000000000..50321fbb0b
--- /dev/null
+++ b/crates/engine/src/cmd/chart.rs
@@ -0,0 +1,245 @@
+//! Insert › Chart and the Chart Design tab: insert a chart, change its type, data, title, legend
+//! and data labels.
+//!
+//! A chart is an inline [`InlineObject::Graphic`] whose graphic keeps its model
+//! ([`ChartSpec`]); it is drawn by the same code that draws charts read from files, and saved as
+//! a chart part with its data in it (see `wordcraft_docx::chart_xml`). Charts made by other
+//! programs are shown as they are; the chart commands only edit charts with a model.
+
+use std::sync::Arc;
+
+use serde_json::{Value, json};
+use wordcraft_doc::chart::{ChartSeries, ChartSpec, ChartType, LegendPos, MAX_POINTS, MAX_SERIES};
+use wordcraft_doc::graphic::{Graphic, GraphicKind};
+use wordcraft_doc::para::{Float, InlineObject};
+use wordcraft_doc::props::Rgb;
+
+use super::objects::selected;
+use super::{delete_selection, sel_result};
+use crate::{CmdError, CmdResult, CommandSpec, Selection, Session, p};
+
+/// A new chart's size: 15 × 7.5 cm, points.
+pub const DEFAULT_W: f32 = 15.0 / 2.54 * 72.0;
+pub const DEFAULT_H: f32 = 7.5 / 2.54 * 72.0;
+
+const TYPES: &str = "column|columnStacked|bar|barStacked|line|area|pie|doughnut|scatter";
+const DATA: &str = r#"{"categories": [string], "series": [{"name": string, "values": [number|null]}]}"#;
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec::new("insert.chart", "Chart", "Insert › Illustrations", insert).params(
+            r#"{"type"?: "column|columnStacked|bar|barStacked|line|area|pie|doughnut|scatter", "data"?: {"categories": [string], "series": [{"name": string, "values": [number|null]}]}, "title"?: string, "legend"?: "right|left|top|bottom|none", "dataLabels"?: bool, "width"?: pt, "height"?: pt} (no params: the chart type picker)"#,
+        ),
+        CommandSpec::new("chart.type", "Change Chart Type", "Chart Design › Type", |s, v| {
+            let kind = chart_type(v)?.ok_or_else(|| CmdError::Params(format!("`type` is required: {TYPES}")))?;
+            edit(s, |c| {
+                c.kind = kind;
+                Ok(())
+            })
+        })
+        .params(r#"{"type": "column|columnStacked|bar|barStacked|line|area|pie|doughnut|scatter"}"#)
+        .when(has_chart),
+        CommandSpec::new("chart.editData", "Edit Data", "Chart Design › Data", |s, v| {
+            let d = v.get("data").unwrap_or(v);
+            let (cats, series) = (d.get("categories"), d.get("series"));
+            if cats.is_none() && series.is_none() {
+                return Err(CmdError::Params(format!("`data` is required: {DATA}")));
+            }
+            let cats = cats.map(categories).transpose()?;
+            let series = series.map(series_list).transpose()?;
+            edit(s, move |c| {
+                if let Some(cats) = &cats {
+                    c.categories = cats.clone();
+                }
+                if let Some(series) = &series {
+                    c.series = series.clone();
+                }
+                Ok(())
+            })
+        })
+        .params(r#"{"data": {"categories"?: [string], "series"?: [{"name": string, "values": [number|null]}]}}"#)
+        .when(has_chart),
+        CommandSpec::new("chart.title", "Chart Title", "Chart Design › Chart Layouts › Add Chart Element", |s, v| {
+            let text = match v.get("text") {
+                Some(Value::String(t)) => Some(Some(t.clone())),
+                Some(Value::Null) => Some(None),
+                None => None,
+                Some(_) => return Err(CmdError::Params("`text`: a string, or null for no title".into())),
+            };
+            edit(s, move |c| {
+                c.title = match &text {
+                    Some(t) => t.clone(),
+                    // No text given: switch the title on (placeholder) or off.
+                    None if c.title.is_some() => None,
+                    None => Some("Chart Title".into()),
+                };
+                Ok(())
+            })
+        })
+        .params(r#"{"text"?: string|null} (no text: switch the title on or off)"#)
+        .when(has_chart),
+        CommandSpec::new("chart.legend", "Legend", "Chart Design › Chart Layouts › Add Chart Element", |s, v| {
+            let pos = match p::str(v, "pos").or_else(|| p::str(v, "position")) {
+                Some(id) if id.eq_ignore_ascii_case("none") => Some(None),
+                Some(id) => Some(Some(LegendPos::from_id(id).ok_or_else(|| CmdError::Params("`pos`: right|left|top|bottom|none".into()))?)),
+                None => None,
+            };
+            edit(s, move |c| {
+                c.legend = match pos {
+                    Some(p) => p,
+                    None if c.legend.is_some() => None,
+                    None => Some(LegendPos::Bottom),
+                };
+                Ok(())
+            })
+        })
+        .params(r#"{"pos"?: "right|left|top|bottom|none"} (no pos: switch the legend on or off)"#)
+        .when(has_chart),
+        CommandSpec::new("chart.dataLabels", "Data Labels", "Chart Design › Chart Layouts › Add Chart Element", |s, v| {
+            let on = p::bool(v, "on").or_else(|| p::bool(v, "value"));
+            edit(s, move |c| {
+                c.data_labels = on.unwrap_or(!c.data_labels);
+                Ok(())
+            })
+        })
+        .params(r#"{"on"?: bool} (no value: switch the data labels on or off)"#)
+        .when(has_chart),
+    ]
+}
+
+/// The selected chart's model, when it has one.
+pub fn selected_chart(s: &Session) -> Option<Arc<ChartSpec>> {
+    match selected(s) {
+        Some((_, InlineObject::Graphic { graphic, .. })) => graphic.chart.clone(),
+        _ => None,
+    }
+}
+
+fn has_chart(s: &Session) -> Option<&'static str> {
+    match selected(s) {
+        Some((_, InlineObject::Graphic { graphic, .. })) if graphic.chart.is_some() => None,
+        Some((_, InlineObject::Graphic { graphic, .. })) if graphic.kind == GraphicKind::Chart => {
+            Some("this chart was made in another program: WordCraft shows it but can't edit it")
+        }
+        _ => Some("select a chart first"),
+    }
+}
+
+/// The graphic for `spec` drawn `w` × `h` points in the theme's colours.
+pub fn chart_graphic(spec: ChartSpec, theme: &[Rgb], w: f32, h: f32) -> Graphic {
+    let spec = spec.sanitized();
+    let items = wordcraft_docx::chart_items(&spec, theme, w, h);
+    Graphic { kind: GraphicKind::Chart, items, w, h, source: None, chart: Some(Arc::new(spec)), smart_art: None }
+}
+
+/// `type` of the params, if given.
+fn chart_type(v: &Value) -> Result<Option<ChartType>, CmdError> {
+    match p::str(v, "type") {
+        Some(id) => ChartType::from_id(id).map(Some).ok_or_else(|| CmdError::Params(format!("unknown chart type `{id}`: {TYPES}"))),
+        None if v.get("type").is_some_and(|t| !t.is_null()) => Err(CmdError::Params(format!("`type`: {TYPES}"))),
+        None => Ok(None),
+    }
+}
+
+fn insert(s: &mut Session, v: &Value) -> CmdResult {
+    let kind = chart_type(v)?;
+    // No type and no data: Insert › Chart's picker, as the ribbon button does.
+    if kind.is_none() && v.get("data").is_none() {
+        s.ui_requests.push(json!({"open": "insertChart"}));
+        return sel_result(s);
+    }
+    let kind = kind.unwrap_or_default();
+    let mut spec = ChartSpec::sample(kind);
+    if let Some(d) = v.get("data") {
+        spec.categories = d.get("categories").map(categories).transpose()?.unwrap_or_default();
+        spec.series = d.get("series").map(series_list).transpose()?.unwrap_or_default();
+        if spec.series.is_empty() {
+            return Err(CmdError::Params(format!("`data.series` needs at least one series: {DATA}")));
+        }
+    }
+    spec.title = p::str(v, "title").map(str::to_string);
+    match p::str(v, "legend") {
+        Some(id) if id.eq_ignore_ascii_case("none") => spec.legend = None,
+        Some(id) => spec.legend = Some(LegendPos::from_id(id).ok_or_else(|| CmdError::Params("`legend`: right|left|top|bottom|none".into()))?),
+        None => {}
+    }
+    spec.data_labels = p::bool(v, "dataLabels").unwrap_or(false);
+    // Fitted to the text width, as Word sizes a new chart.
+    let max_w = s.doc.sections().first().map(|(_, sp)| sp.text_width()).unwrap_or(468.0).max(36.0);
+    let w = p::f32(v, "width").unwrap_or(DEFAULT_W).clamp(36.0, 2000.0).min(max_w);
+    let h = p::f32(v, "height").unwrap_or(DEFAULT_H).clamp(36.0, 2000.0);
+    let graphic = chart_graphic(spec, &s.doc.settings.theme_colors, w, h);
+    let out = json!({"chart": graphic.chart.as_deref(), "width": w, "height": h});
+    let props = s.typing_props();
+    let at = delete_selection(s)?;
+    let obj = InlineObject::Graphic { w, h, alt: String::new(), float: Float::default(), graphic: Arc::new(graphic) };
+    let end = s.doc.insert_object(&at, obj, &props)?;
+    s.sel = Selection { anchor: at, focus: end };
+    Ok(out)
+}
+
+/// Change the selected chart's model with `f`, then draw it again at its size.
+fn edit(s: &mut Session, f: impl Fn(&mut ChartSpec) -> Result<(), CmdError>) -> CmdResult {
+    let (pos, obj) = selected(s).ok_or_else(|| CmdError::Disabled("select a chart first".into()))?;
+    let InlineObject::Graphic { w, h, graphic, .. } = obj else { return Err(CmdError::Disabled("select a chart first".into())) };
+    let mut spec = graphic.chart.as_deref().cloned().ok_or_else(|| CmdError::Disabled("this chart can't be edited".into()))?;
+    f(&mut spec)?;
+    let next = Arc::new(chart_graphic(spec, &s.doc.settings.theme_colors, w, h));
+    let out = json!({"chart": next.chart.as_deref()});
+    let para = s.doc.para_mut(pos.story, &pos.path)?;
+    if let Some(InlineObject::Graphic { graphic, .. }) = para.object_at_mut(pos.off) {
+        *graphic = next;
+    }
+    para.touch();
+    Ok(out)
+}
+
+/// Draw the chart of `o` again at its current size (after a resize), if it has a model.
+pub fn redraw(o: &mut InlineObject, theme: &[Rgb]) {
+    if let InlineObject::Graphic { w, h, graphic, .. } = o
+        && let Some(spec) = graphic.chart.as_deref()
+    {
+        *graphic = Arc::new(chart_graphic(spec.clone(), theme, *w, *h));
+    }
+}
+
+/// Category labels from JSON: strings, or numbers written as text.
+fn categories(v: &Value) -> Result<Vec<String>, CmdError> {
+    let a = v.as_array().ok_or_else(|| CmdError::Params("`categories`: an array of strings".into()))?;
+    Ok(a.iter().take(MAX_POINTS).map(cell_text).collect())
+}
+
+fn cell_text(v: &Value) -> String {
+    match v {
+        Value::String(t) => wordcraft_doc::chart::clean_text(t),
+        Value::Null => String::new(),
+        other => wordcraft_doc::chart::clean_text(&other.to_string()),
+    }
+}
+
+/// Series from JSON: `[{"name", "values": [number|null|numeric string]}]`.
+fn series_list(v: &Value) -> Result<Vec<ChartSeries>, CmdError> {
+    let a = v.as_array().ok_or_else(|| CmdError::Params(format!("`series`: {DATA}")))?;
+    a.iter()
+        .take(MAX_SERIES)
+        .map(|s| {
+            let name = s.get("name").map(cell_text).unwrap_or_default();
+            let values = match s.get("values") {
+                Some(Value::Array(vals)) => vals.iter().take(MAX_POINTS).map(number).collect(),
+                None | Some(Value::Null) => Vec::new(),
+                Some(_) => return Err(CmdError::Params("`values`: an array of numbers (null for none)".into())),
+            };
+            Ok(ChartSeries { name, values })
+        })
+        .collect()
+}
+
+/// A value: a number, or text that reads as one; anything else (or not finite) is no value.
+fn number(v: &Value) -> Option<f64> {
+    match v {
+        Value::Number(n) => n.as_f64(),
+        Value::String(t) => t.trim().parse::<f64>().ok(),
+        _ => None,
+    }
+    .filter(|x| x.is_finite())
+}
diff --git a/crates/engine/src/cmd/citations.rs b/crates/engine/src/cmd/citations.rs
index bdd667b6b3..2793b1363d 100644
--- a/crates/engine/src/cmd/citations.rs
+++ b/crates/engine/src/cmd/citations.rs
@@ -297,6 +297,8 @@ pub fn specs() -> Vec<CommandSpec> {
                 CmdError::Params(format!("style must be one of {:?}", STYLES.iter().map(|x| x.name).collect::<Vec<_>>()))
             })?;
             s.bib_style = st.name.to_string();
+            // Recorded in the document too, so a save keeps it.
+            s.doc.settings.bib_style = Some(st.name.to_string());
             update_citations(s)?;
             Ok(json!({"style": s.bib_style}))
         })
@@ -319,28 +321,6 @@ pub fn specs() -> Vec<CommandSpec> {
             update_generated(s)?;
             sel_result(s)
         }),
-        CommandSpec::new("references.markEntry", "Mark Entry", "References › Index", |s, v| {
-            let entry = match p::str(v, "entry") {
-                Some(e) => e.to_string(),
-                None => s.selected_text().trim().to_string(),
-            };
-            if entry.is_empty() {
-                return Err(CmdError::Params("select a word or give `entry`".into()));
-            }
-            let (_, b) = s.sel.ordered();
-            s.doc.insert_object(&b, InlineObject::Field { instr: format!("XE \"{}\"", entry.replace('"', "")), result: String::new(), locked: false, code: false }, &CharProps { hidden: Some(true), ..Default::default() })?;
-            Ok(json!({"entry": entry}))
-        })
-        .params(r#"{"entry"?: string}"#)
-        .key(super::non_mac("Alt+Shift+X")),
-        CommandSpec::new("references.index", "Insert Index", "References › Index", |s, _| {
-            generated_list(s, "INDEX", "Index")?;
-            sel_result(s)
-        }),
-        CommandSpec::new("references.updateIndex", "Update Index", "References › Index", |s, _| {
-            update_generated(s)?;
-            sel_result(s)
-        }),
         CommandSpec::new("references.markCitation", "Mark Citation", "References › Table of Authorities", |s, v| {
             let entry = p::str(v, "entry").map(str::to_string).unwrap_or_else(|| s.selected_text().trim().to_string());
             if entry.is_empty() {
@@ -356,6 +336,10 @@ pub fn specs() -> Vec<CommandSpec> {
             generated_list(s, "TOA", "Table of Authorities")?;
             sel_result(s)
         }),
+        CommandSpec::new("references.updateAuthorities", "Update Table", "References › Table of Authorities", |s, _| {
+            update_generated(s)?;
+            sel_result(s)
+        }),
         CommandSpec::new("insert.crossReference", "Cross-reference", "Insert › Links", cross_ref)
             .params(r#"{"to": "heading|bookmark|figure|table", "target": string (text / name / number), "show"?: "text|page|number|aboveBelow"} or {} to list targets"#),
         CommandSpec::new("references.noteOptions", "Footnote and Endnote", "References › Footnotes", super::references::note_options).params(
@@ -547,8 +531,16 @@ fn sources(s: &mut Session, v: &Value) -> CmdResult {
                 .collect();
             src.tag = format!("{base}{}", src.year);
         }
-        s.doc.sources.retain(|x| x.tag != src.tag);
-        s.doc.sources.push(src);
+        // Edit Source keeps the source's place in the list and refreshes its citations.
+        match s.doc.sources.iter().position(|x| x.tag == src.tag) {
+            Some(i) => {
+                if let Some(x) = s.doc.sources.get_mut(i) {
+                    *x = src;
+                }
+                update_citations(s)?;
+            }
+            None => s.doc.sources.push(src),
+        }
         s.touch();
     }
     if let Some(t) = p::str(v, "remove") {
@@ -685,7 +677,7 @@ fn refresh_citations(s: &mut Session) -> Result<(), CmdError> {
 
 /// Generated lists (BIBLIOGRAPHY, INDEX, table of figures, TOA): a heading paragraph holding
 /// the field, then entry paragraphs marked with the "GeneratedEntry" style family.
-fn generated_list(s: &mut Session, instr: &str, title: &str) -> Result<(), CmdError> {
+pub(crate) fn generated_list(s: &mut Session, instr: &str, title: &str) -> Result<(), CmdError> {
     let at = delete_selection(s)?;
     if at.story != StoryRef::Body || at.path.depth() > 0 {
         return Err(CmdError::Failed("lists go in the main text".into()));
@@ -734,6 +726,11 @@ pub fn update_generated(s: &mut Session) -> Result<(), CmdError> {
             i += 1;
             continue;
         };
+        if kind.starts_with("INDEX") {
+            super::index::rebuild(s, i, None)?;
+            i += 1;
+            continue;
+        }
         // Remove old entries.
         while s.doc.body.get(i + 1).and_then(|b| b.as_para()).is_some_and(|p| p.props.style.as_deref() == Some(ENTRY_STYLE)) {
             s.doc.remove_block(StoryRef::Body, &Path::top(i + 1))?;
@@ -981,6 +978,71 @@ mod tests {
         assert!(s.doc.plain_text(StoryRef::Body).contains("[1]"));
     }
 
+    #[test]
+    fn bibliography_round_trip_docx() {
+        let mut s = Session::new(wordcraft_doc::Document::new());
+        s.run("text.insert", &json!({"text": "Studios matter "})).unwrap();
+        s.run(
+            "references.citation",
+            &json!({
+                "source": {
+                    "author": "Rivera, Alex; Chen, Mei",
+                    "title": "Shared Spaces",
+                    "year": "2021",
+                    "publisher": "Harbor Books",
+                    "city": "Portland",
+                    "editor": "Johnson, Robert",
+                    "edition": "2nd",
+                    "issue": "4",
+                    "month": "10",
+                    "day": "15",
+                    "accessed": "2024-05-15",
+                    "doi": "10.1000/182"
+                }
+            }),
+        )
+        .unwrap();
+        s.run("text.newParagraph", &json!({})).unwrap();
+        s.run("references.bibliography", &json!({})).unwrap();
+
+        // Serialize to DOCX and back — sources must survive.
+        let bytes = wordcraft_docx::write(&s.doc).expect("docx write");
+        let doc = wordcraft_docx::read(&bytes).expect("docx read");
+        assert_eq!(doc.sources.len(), 1, "round-tripped sources: {:?}", doc.sources);
+        assert_eq!(doc.sources[0].author, "Rivera, Alex; Chen, Mei");
+        assert_eq!(doc.sources[0].title, "Shared Spaces");
+        assert_eq!(doc.sources[0].editor, "Johnson, Robert");
+        assert_eq!(doc.sources[0].edition, "2nd");
+        assert_eq!(doc.sources[0].issue, "4");
+        assert_eq!(doc.sources[0].month, "10");
+        assert_eq!(doc.sources[0].day, "15");
+        assert_eq!(doc.sources[0].accessed, "2024-05-15");
+        assert_eq!(doc.sources[0].doi, "10.1000/182");
+
+        // Round-tripped document in a new session works with citation styles.
+        let mut s2 = Session::new(doc);
+        s2.run("references.citationStyle", &json!({"style": "Harvard (Anglia)"})).unwrap();
+        let t = s2.doc.plain_text(StoryRef::Body);
+        assert!(t.contains("(Rivera and Chen, 2021)"), "{t}");
+        assert!(t.contains("Rivera, A. and Chen, M., 2021. Shared Spaces. Portland: Harbor Books."), "{t}");
+    }
+
+    #[test]
+    fn citation_style_survives_docx_save_and_reopen() {
+        let mut s = Session::new(wordcraft_doc::Document::new());
+        s.run("references.citation", &json!({"source": {"author": "Rivera, Alex", "title": "Shared Spaces", "year": "2021"}})).unwrap();
+        s.run("references.citationStyle", &json!({"style": "Harvard (Anglia)"})).unwrap();
+        let bytes = wordcraft_docx::write(&s.doc).expect("docx write");
+        let doc = wordcraft_docx::read(&bytes).expect("docx read");
+        assert_eq!(doc.settings.bib_style.as_deref(), Some("Harvard (Anglia)"));
+        assert_eq!(Session::new(doc.clone()).bib_style, "Harvard (Anglia)");
+        let mut other = Session::new(wordcraft_doc::Document::new());
+        other.set_document(doc);
+        assert_eq!(other.bib_style, "Harvard (Anglia)");
+        // A document without a recorded style is APA.
+        assert_eq!(Session::new(wordcraft_doc::Document::new()).bib_style, "APA");
+    }
+
     #[test]
     fn index_and_figures() {
         let mut s = Session::new(wordcraft_doc::Document::from_text("Kilns are hot.\nPresses are heavy.\nMore kilns."));
@@ -1008,6 +1070,24 @@ mod tests {
         assert!(fields(&s).contains(&(format!("REF {name} \\h"), "Figure 1".to_string())), "{:?}", fields(&s));
     }
 
+    /// #661: References › Table of Authorities › Update Table picks up citations marked after the table.
+    #[test]
+    fn table_of_authorities_updates() {
+        let mut s = Session::new(wordcraft_doc::Document::from_text("Smith v. Jones held it.\nDoe v. Roe agreed."));
+        s.run("select.text", &json!({"text": "Smith v. Jones"})).unwrap();
+        s.run("references.markCitation", &json!({})).unwrap();
+        s.run("caret.docEnd", &json!({})).unwrap();
+        s.run("text.newParagraph", &json!({})).unwrap();
+        s.run("references.tableOfAuthorities", &json!({})).unwrap();
+        let t = s.doc.plain_text(StoryRef::Body);
+        assert!(t.contains("Smith v. Jones") && !t.contains("Doe v. Roe, "), "{t}");
+        s.run("select.text", &json!({"text": "Doe v. Roe"})).unwrap();
+        s.run("references.markCitation", &json!({})).unwrap();
+        s.run("references.updateAuthorities", &json!({})).unwrap();
+        let after = s.doc.plain_text(StoryRef::Body);
+        assert!(after.matches("Doe v. Roe").count() > t.matches("Doe v. Roe").count(), "{after}");
+    }
+
     /// Field instructions and results in the body, in order.
     fn fields(s: &Session) -> Vec<(String, String)> {
         let mut out = Vec::new();
diff --git a/crates/engine/src/cmd/connectors.rs b/crates/engine/src/cmd/connectors.rs
new file mode 100644
index 0000000000..adadd0a7c3
--- /dev/null
+++ b/crates/engine/src/cmd/connectors.rs
@@ -0,0 +1,292 @@
+//! Connectors: gluing a connector's ends to shapes' connection sites (`shape.connect`), and
+//! re-routing glued connectors when the shapes they join move or change size ([`reroute`], run by
+//! the session after object edits).
+//!
+//! Floating connectors in the body are routed on the page (from the layout); connectors inside a
+//! group, in the group's own space. A glue to a shape that is gone (or on another page) leaves
+//! that end where it is.
+
+use std::collections::HashMap;
+
+use serde_json::{Value, json};
+use wordcraft_doc::connector::{ConnEnd, Frame, ends, nearest_site, route, site_point};
+use wordcraft_doc::para::{Anchor, InlineObject, Wrap};
+use wordcraft_doc::{Pos, StoryRef};
+
+use crate::{CmdError, CmdResult, CommandSpec, Session, p};
+
+/// How close (points) a dragged end must come to a connection site to glue to it.
+pub const SNAP: f32 = 12.0;
+/// Largest offset a routed connector gets, points.
+const MAX_OFFSET: f32 = 4000.0;
+
+fn has_connector(s: &Session) -> Option<&'static str> {
+    match super::objects::selected(s) {
+        Some((_, InlineObject::Shape { kind, .. })) if kind.is_connector() => None,
+        _ => Some("select a connector first"),
+    }
+}
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec::new("shape.connect", "Connect Shapes", "Shape Format › Insert Shapes", connect)
+            .params(
+                r#"{"start"?: end, "end"?: end}  end: {"path": [..], "off": n, "site"?: n} (glue to that body shape's connection site; nearest one when omitted) | {"x": pt, "y": pt, "page"?: n} (drag the end there: it glues to a shape's site within 12 pt, else stays free there) | null (unglue)"#,
+            )
+            .when(has_connector),
+    ]
+}
+
+/// Commands after which glued connectors are re-routed: those that move, resize, turn, add or
+/// change drawings.
+pub fn reroutes_after(id: &str) -> bool {
+    id.starts_with("arrange.") || id.starts_with("shape.") || id.starts_with("picture.") || id == "insert.shape" || id.starts_with("draw.")
+}
+
+/// The body's floating drawings with an id (by id) and its glued connectors.
+fn scan(s: &Session) -> (HashMap<u32, Pos>, Vec<Pos>, Vec<Pos>) {
+    let (mut ids, mut conns, mut groups) = (HashMap::new(), Vec::new(), Vec::new());
+    for path in s.doc.para_paths(StoryRef::Body) {
+        let Some(para) = s.doc.para(StoryRef::Body, &path) else { continue };
+        for off in para.object_offsets() {
+            let pos = Pos { story: StoryRef::Body, path: path.clone(), off };
+            match para.object_at(off) {
+                Some(InlineObject::Shape { kind, extra, float, .. }) => {
+                    if extra.id != 0 {
+                        ids.entry(extra.id).or_insert(pos.clone());
+                    }
+                    if kind.is_connector() && float.wrap != Wrap::Inline && (extra.start.is_some() || extra.end.is_some()) {
+                        conns.push(pos);
+                    }
+                }
+                Some(InlineObject::Group { children, .. })
+                    if children.iter().any(|c| matches!(&c.obj, InlineObject::Shape { kind, extra, .. } if kind.is_connector() && (extra.start.is_some() || extra.end.is_some()))) =>
+                {
+                    groups.push(pos)
+                }
+                _ => {}
+            }
+        }
+    }
+    (ids, conns, groups)
+}
+
+/// Re-route every glued connector to the shapes it joins. Returns whether anything moved.
+pub fn reroute(s: &mut Session) -> bool {
+    let (ids, conns, groups) = scan(s);
+    let mut moved = false;
+    for pos in groups {
+        if let Ok(para) = s.doc.para_mut(pos.story, &pos.path)
+            && let Some(InlineObject::Group { children, .. }) = para.object_at_mut(pos.off)
+            && wordcraft_doc::connector::reroute_group(children)
+        {
+            para.touch();
+            moved = true;
+        }
+    }
+    if conns.is_empty() || ids.is_empty() {
+        return moved;
+    }
+    if moved {
+        s.touch();
+    }
+    let layout = s.layout();
+    let site = |e: Option<ConnEnd>, page: usize| -> Option<(f32, f32)> {
+        let e = e?;
+        let target = ids.get(&e.id)?;
+        let hit = layout.object(target, page)?;
+        let kind = match s.doc.para_at(target)?.object_at(target.off)? {
+            InlineObject::Shape { kind, .. } => *kind,
+            _ => return None,
+        };
+        (hit.page == page).then(|| site_point(kind, [hit.rect.x, hit.rect.y, hit.rect.w, hit.rect.h], hit.spin, e.site))?
+    };
+    let mut plans = Vec::new();
+    for pos in conns {
+        let Some(hit) = layout.object(&pos, s.page_hint) else { continue };
+        let Some(InlineObject::Shape { extra, float, .. }) = s.doc.para_at(&pos).and_then(|p| p.object_at(pos.off)) else { continue };
+        let r = hit.rect;
+        let (s0, e0) = ends(r.x, r.y, r.w, r.h, float.flip_h, float.flip_v);
+        let to = route(site(extra.start, hit.page).unwrap_or(s0), site(extra.end, hit.page).unwrap_or(e0));
+        plans.push((pos, to, (r.x, r.y), (hit.origin.x, hit.origin.y)));
+    }
+    for (pos, to, at, origin) in plans {
+        moved |= place(s, &pos, to, at, origin);
+    }
+    moved
+}
+
+/// Put the floating connector at `pos` (now with its frame's top-left at page point `at`, its
+/// anchor's origin at `origin`) in frame `to`. Returns whether it changed.
+fn place(s: &mut Session, pos: &Pos, to: Frame, at: (f32, f32), origin: (f32, f32)) -> bool {
+    let Ok(para) = s.doc.para_mut(pos.story, &pos.path) else { return false };
+    let Some(InlineObject::Shape { w, h, float, .. }) = para.object_at_mut(pos.off) else { return false };
+    let near = |a: f32, b: f32| (a - b).abs() < 0.01;
+    if near(to.x, at.0)
+        && near(to.y, at.1)
+        && near(to.w, *w)
+        && near(to.h, *h)
+        && to.flip_h == float.flip_h
+        && to.flip_v == float.flip_v
+        && float.rot == 0.0
+    {
+        return false;
+    }
+    let clamp = |v: f32| wordcraft_geom::finite(v).clamp(-MAX_OFFSET, MAX_OFFSET);
+    // An aligned position becomes an offset from the column / paragraph (where `origin` is).
+    if float.h_align.take().is_some() {
+        float.h_rel = Anchor::Column;
+        float.x = clamp(to.x - origin.0);
+    } else {
+        float.x = clamp(float.x + to.x - at.0);
+    }
+    if float.v_align.take().is_some() {
+        float.v_rel = Anchor::Paragraph;
+        float.y = clamp(to.y - origin.1);
+    } else {
+        float.y = clamp(float.y + to.y - at.1);
+    }
+    *w = to.w.clamp(0.0, MAX_OFFSET);
+    *h = to.h.clamp(0.0, MAX_OFFSET);
+    float.rot = 0.0;
+    float.flip_h = to.flip_h;
+    float.flip_v = to.flip_v;
+    para.touch();
+    true
+}
+
+/// A body position from `{"path": [..], "off": n}` (or any form `parse_pos` reads).
+fn body_pos(e: &Value) -> Option<Pos> {
+    let path: Option<Vec<u32>> =
+        e.get("path").and_then(Value::as_array).map(|a| a.iter().take(64).filter_map(Value::as_u64).filter_map(|x| u32::try_from(x).ok()).collect());
+    match (path, p::u64(e, "off").and_then(|o| usize::try_from(o).ok())) {
+        (Some(path), Some(off)) if !path.is_empty() => Some(Pos { story: StoryRef::Body, path: wordcraft_doc::Path(path), off }),
+        _ => super::parse_pos(e).filter(|t| t.story == StoryRef::Body),
+    }
+}
+
+/// Give the drawing at `pos` a drawing id if it has none; returns it.
+fn ensure_id(s: &mut Session, pos: &Pos) -> Result<u32, CmdError> {
+    let next = s.doc.next_shape_id();
+    let para = s.doc.para_mut(pos.story, &pos.path)?;
+    let (id, fresh) = match para.object_at_mut(pos.off) {
+        Some(InlineObject::Shape { extra, kind, .. }) if !kind.is_connector() => {
+            let fresh = extra.id == 0;
+            if fresh {
+                extra.id = next;
+            }
+            (extra.id, fresh)
+        }
+        _ => return Err(CmdError::Params("connectors glue to shapes and text boxes".into())),
+    };
+    if fresh {
+        para.touch();
+    }
+    Ok(id)
+}
+
+/// `shape.connect`: glue, move or unglue the selected connector's ends.
+fn connect(s: &mut Session, v: &Value) -> CmdResult {
+    let (pos, obj) = super::objects::selected(s).ok_or_else(|| CmdError::Disabled("select a connector first".into()))?;
+    let InlineObject::Shape { kind, float, .. } = &obj else { return Err(CmdError::Disabled("select a connector first".into())) };
+    if !kind.is_connector() {
+        return Err(CmdError::Disabled("select a connector first".into()));
+    }
+    if pos.story != StoryRef::Body || float.wrap == Wrap::Inline {
+        return Err(CmdError::Disabled("only floating connectors in the body text can be glued".into()));
+    }
+    let (fh, fv) = (float.flip_h, float.flip_v);
+    let layout = s.layout();
+    let hit = layout.object(&pos, s.page_hint).ok_or_else(|| CmdError::Failed("the connector isn't laid out".into()))?;
+    let r = hit.rect;
+    let (mut p0, mut p1) = ends(r.x, r.y, r.w, r.h, fh, fv);
+    let mut glue: [Option<Option<ConnEnd>>; 2] = [None, None];
+    for (i, key) in ["start", "end"].into_iter().enumerate() {
+        let Some(e) = v.get(key) else { continue };
+        if e.is_null() {
+            glue[i] = Some(None);
+            continue;
+        }
+        let here = if i == 0 { p0 } else { p1 };
+        let (target, site) = if e.get("path").is_some() {
+            let at = body_pos(e).ok_or_else(|| CmdError::Params(format!("`{key}`: no shape there")))?;
+            let th = layout
+                .object(&at, hit.page)
+                .filter(|t| t.page == hit.page)
+                .ok_or_else(|| CmdError::Params(format!("`{key}`: no shape there on this page")))?;
+            let tkind = match s.doc.para_at(&at).and_then(|p| p.object_at(at.off)) {
+                Some(InlineObject::Shape { kind, .. }) if !kind.is_connector() => *kind,
+                _ => return Err(CmdError::Params(format!("`{key}`: connectors glue to shapes and text boxes"))),
+            };
+            let rect = [th.rect.x, th.rect.y, th.rect.w, th.rect.h];
+            let site = match p::u64(e, "site") {
+                Some(n) => u32::try_from(n)
+                    .ok()
+                    .filter(|n| site_point(tkind, rect, th.spin, *n).is_some())
+                    .ok_or_else(|| CmdError::Params(format!("`{key}`: no such connection site")))?,
+                None => nearest_site(tkind, rect, th.spin, here).map(|(n, ..)| n).unwrap_or(0),
+            };
+            (Some(at), site)
+        } else {
+            let (x, y) = (p::f32(e, "x").ok_or_else(|| CmdError::Params(format!("`{key}`: a shape or a point")))?, p::f32(e, "y").unwrap_or(here.1));
+            let page = p::u64(e, "page").map_or(hit.page, |n| usize::try_from(n).unwrap_or(usize::MAX));
+            if page != hit.page {
+                return Err(CmdError::Params("a connector's ends stay on its page".into()));
+            }
+            // The nearest site of a shape (not a connector) within reach.
+            let mut best: Option<(Pos, u32, f32)> = None;
+            if let Some(pg) = layout.pages.get(page) {
+                for it in &pg.items {
+                    let wordcraft_layout::Placed::Object { rect, spin, story: StoryRef::Body, path, off, .. } = it else { continue };
+                    let at = Pos { story: StoryRef::Body, path: path.clone(), off: *off };
+                    if at == pos {
+                        continue;
+                    }
+                    let Some(InlineObject::Shape { kind, .. }) = s.doc.para_at(&at).and_then(|p| p.object_at(at.off)) else { continue };
+                    if kind.is_connector() {
+                        continue;
+                    }
+                    if let Some((n, _, d)) = nearest_site(*kind, [rect.x, rect.y, rect.w, rect.h], *spin, (x, y))
+                        && d <= SNAP
+                        && best.as_ref().is_none_or(|b| d < b.2)
+                    {
+                        best = Some((at, n, d));
+                    }
+                }
+            }
+            match best {
+                Some((at, n, _)) => (Some(at), n),
+                None => {
+                    // A free end, moved there.
+                    if i == 0 {
+                        p0 = (x, y);
+                    } else {
+                        p1 = (x, y);
+                    }
+                    glue[i] = Some(None);
+                    continue;
+                }
+            }
+        };
+        if let Some(at) = target {
+            let id = ensure_id(s, &at)?;
+            glue[i] = Some(Some(ConnEnd { id, site }));
+        }
+    }
+    // Free ends first, then glued ones are routed.
+    let para = s.doc.para_mut(pos.story, &pos.path)?;
+    if let Some(InlineObject::Shape { extra, .. }) = para.object_at_mut(pos.off) {
+        if let Some(g) = glue[0] {
+            extra.start = g;
+        }
+        if let Some(g) = glue[1] {
+            extra.end = g;
+        }
+        para.touch();
+    }
+    place(s, &pos, route(p0, p1), (r.x, r.y), (hit.origin.x, hit.origin.y));
+    s.touch();
+    reroute(s);
+    let o = s.doc.para_at(&pos).and_then(|p| p.object_at(pos.off)).cloned();
+    Ok(json!({"object": serde_json::to_value(o).unwrap_or(Value::Null)}))
+}
diff --git a/crates/engine/src/cmd/controls.rs b/crates/engine/src/cmd/controls.rs
new file mode 100644
index 0000000000..e9f5320454
--- /dev/null
+++ b/crates/engine/src/cmd/controls.rs
@@ -0,0 +1,827 @@
+//! Developer › Controls: content controls (see [`wordcraft_doc::control`]) — insert each kind,
+//! set their properties, tick check boxes, choose list entries and dates, Design Mode.
+//!
+//! Typing into a control that shows its placeholder replaces the placeholder; deleting all of a
+//! control's content brings the placeholder back; locked controls refuse to be deleted
+//! (`sdtLocked`) or edited (`contentLocked`). Those rules live here and are called from the
+//! typing and deleting commands.
+
+use serde_json::{Value, json};
+use wordcraft_doc::control::{ContentControl, ControlKind, ControlLock, ControlRange, ListItem, MAX_CONTROL_TEXT, MAX_LIST_ITEMS};
+use wordcraft_doc::para::OBJ;
+use wordcraft_doc::props::{CharProps, Rgb, TextColor};
+use wordcraft_doc::styles::{Style, StyleKind};
+use wordcraft_doc::{InlineObject, Pos, StoryRef};
+
+use super::{delete_selection, sel_result};
+use crate::{CmdError, CmdResult, CommandSpec, Selection, Session, p};
+
+const LOC: &str = "Developer › Controls";
+/// The character style placeholder text is shown in.
+pub const PLACEHOLDER_STYLE: &str = "PlaceholderText";
+
+pub fn specs() -> Vec<CommandSpec> {
+    const INSERT: &str = r#"{"title"?: string, "tag"?: string}"#;
+    const LIST: &str = r#"{"title"?: string, "tag"?: string, "items"?: [string | {"display": string, "value"?: string}]}"#;
+    vec![
+        CommandSpec::new("developer.richText", "Rich Text Content Control", LOC, |s, v| insert(s, v, ControlKind::RichText)).params(INSERT),
+        CommandSpec::new("developer.plainText", "Plain Text Content Control", LOC, |s, v| insert(s, v, ControlKind::Text { multi_line: false }))
+            .params(INSERT),
+        CommandSpec::new("developer.picture", "Picture Content Control", LOC, |s, v| insert(s, v, ControlKind::Picture)).params(INSERT),
+        CommandSpec::new("developer.buildingBlock", "Building Block Gallery Content Control", LOC, |s, v| {
+            insert(s, v, ControlKind::Gallery { list: true, gallery: "Quick Parts".into(), category: "General".into(), unique: false })
+        })
+        .params(INSERT),
+        CommandSpec::new("developer.checkBox", "Check Box Content Control", LOC, |s, v| insert(s, v, ControlKind::check_box()))
+            .params(r#"{"title"?: string, "tag"?: string, "checked"?: bool}"#),
+        CommandSpec::new("developer.comboBox", "Combo Box Content Control", LOC, |s, v| {
+            insert(s, v, ControlKind::ComboBox { items: Vec::new(), last_value: String::new() })
+        })
+        .params(LIST),
+        CommandSpec::new("developer.dropDown", "Drop-Down List Content Control", LOC, |s, v| {
+            insert(s, v, ControlKind::DropDown { items: Vec::new(), last_value: String::new() })
+        })
+        .params(LIST),
+        CommandSpec::new("developer.datePicker", "Date Picker Content Control", LOC, |s, v| {
+            insert(
+                s,
+                v,
+                ControlKind::Date { full_date: String::new(), format: "M/d/yyyy".into(), lid: "en-US".into(), calendar: "gregorian".into(), store_as: "dateTime".into() },
+            )
+        })
+        .params(r#"{"title"?: string, "tag"?: string, "format"?: "M/d/yyyy", "date"?: "YYYY-MM-DD"}"#),
+        CommandSpec::new("developer.repeatingSection", "Repeating Section Content Control", LOC, |s, v| {
+            insert(s, v, ControlKind::RepeatingSection { title: String::new(), no_insert_delete: false })
+        })
+        .params(INSERT),
+        CommandSpec::new("developer.designMode", "Design Mode", LOC, design_mode).params(r#"{"value"?: bool}"#).pure(),
+        CommandSpec::new("developer.properties", "Properties", LOC, properties).params(
+            r#"{"control"?: tag or title, "title"?: string, "tag"?: string, "lockDelete"?: bool, "lockEdit"?: bool, "temporary"?: bool, "multiLine"?: bool, "placeholder"?: string, "items"?: [string | {"display", "value"}], "format"?: "M/d/yyyy", "checkedSymbol"?: char, "uncheckedSymbol"?: char}"#,
+        ),
+        CommandSpec::new("developer.control", "Content Control at Selection", LOC, info).params(r#"{"control"?: tag or title, "at"?: pos}"#).pure(),
+        CommandSpec::new("developer.toggleCheckBox", "Toggle Check Box", LOC, toggle_check_box).params(r#"{"control"?: tag or title, "at"?: pos, "value"?: bool}"#),
+        CommandSpec::new("developer.chooseItem", "Choose List Item", LOC, choose_item)
+            .params(r#"{"control"?: tag or title, "at"?: pos, "index"?: number, "value"?: string, "text"?: string}"#),
+        CommandSpec::new("developer.setDate", "Set Date", LOC, set_date).params(r#"{"control"?: tag or title, "at"?: pos, "date": "YYYY-MM-DD"}"#),
+        CommandSpec::new("developer.removeControl", "Remove Content Control", LOC, remove_control).params(r#"{"control"?: tag or title, "at"?: pos}"#),
+    ]
+}
+
+fn locked(s: &mut Session, msg: &str) -> CmdError {
+    s.status = msg.to_string();
+    CmdError::Failed(msg.to_string())
+}
+
+const CANT_DELETE: &str = "This content control can't be deleted.";
+const CANT_EDIT: &str = "The contents of this content control can't be edited.";
+
+/// A string param, trimmed to what a control keeps.
+fn short(v: &Value, k: &str) -> Option<String> {
+    p::str(v, k).map(|t| t.chars().filter(|c| !c.is_control() && *c != OBJ).take(MAX_CONTROL_TEXT).collect())
+}
+
+/// List entries from `items`: strings, or `{display, value}` objects.
+fn items_param(v: &Value) -> Option<Vec<ListItem>> {
+    let arr = v.get("items")?.as_array()?;
+    let clean = |t: &str| -> String { t.chars().filter(|c| !c.is_control() && *c != OBJ).take(MAX_CONTROL_TEXT).collect() };
+    Some(
+        arr.iter()
+            .take(MAX_LIST_ITEMS)
+            .filter_map(|i| match i {
+                Value::String(t) => Some(ListItem { display: clean(t), value: clean(t) }),
+                Value::Object(_) => {
+                    let display = clean(i.get("display").and_then(Value::as_str)?);
+                    let value = i.get("value").and_then(Value::as_str).map(clean).unwrap_or_else(|| display.clone());
+                    Some(ListItem { display, value })
+                }
+                _ => None,
+            })
+            .filter(|i| !i.display.is_empty())
+            .collect(),
+    )
+}
+
+/// A symbol param: one character, not a control or object character.
+fn symbol_param(v: &Value, k: &str) -> Option<char> {
+    let t = p::str(v, k)?;
+    let mut it = t.chars();
+    let c = it.next()?;
+    (it.next().is_none() && !c.is_control() && c != OBJ).then_some(c)
+}
+
+/// A date `YYYY-MM-DD` (a full ISO date-time is fine too): (year, month, day), checked.
+pub fn parse_date(t: &str) -> Option<(i64, u32, u32)> {
+    let t = t.trim();
+    let y: i64 = t.get(0..4)?.parse().ok()?;
+    let m: u32 = t.get(5..7)?.parse().ok()?;
+    let d: u32 = t.get(8..10)?.parse().ok()?;
+    if t.get(4..5) != Some("-") || t.get(7..8) != Some("-") || !(1..=9999).contains(&y) || !(1..=12).contains(&m) || d == 0 || d > days_in_month(y, m)
+    {
+        return None;
+    }
+    Some((y, m, d))
+}
+
+pub fn days_in_month(y: i64, m: u32) -> u32 {
+    match m {
+        2 if (y % 4 == 0 && y % 100 != 0) || y % 400 == 0 => 29,
+        2 => 28,
+        4 | 6 | 9 | 11 => 30,
+        _ => 31,
+    }
+}
+
+/// Days since 1970-01-01 for a date (inverse of [`super::civil_from_days`]).
+pub fn days_from_civil(y: i64, m: u32, d: u32) -> i64 {
+    let y = if m <= 2 { y - 1 } else { y };
+    let era = if y >= 0 { y } else { y - 399 } / 400;
+    let yoe = y - era * 400;
+    let mp = i64::from((m + 9) % 12);
+    let doy = (153 * mp + 2) / 5 + i64::from(d) - 1;
+    let doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+    era * 146_097 + doe - 719_468
+}
+
+/// The placeholder style, added to the document when it hasn't one.
+fn ensure_placeholder_style(s: &mut Session) {
+    if s.doc.styles.get(PLACEHOLDER_STYLE).is_none() {
+        s.doc.styles.styles.push(Style {
+            id: PLACEHOLDER_STYLE.into(),
+            name: "Placeholder Text".into(),
+            kind: StyleKind::Character,
+            based_on: Some("DefaultParagraphFont".into()),
+            chr: CharProps { color: Some(TextColor::Rgb(Rgb(0x66, 0x66, 0x66))), ..Default::default() },
+            priority: Some(99),
+            builtin: true,
+            ..Default::default()
+        });
+    }
+}
+
+/// Formatting for placeholder text based on `base`.
+fn placeholder_props(s: &mut Session, base: &CharProps) -> CharProps {
+    ensure_placeholder_style(s);
+    CharProps { style: Some(PLACEHOLDER_STYLE.into()), link: None, ..base.clone() }
+}
+
+/// `base` without the placeholder style (for real content).
+fn content_props(base: &CharProps) -> CharProps {
+    let mut p = base.clone();
+    if p.style.as_deref() == Some(PLACEHOLDER_STYLE) {
+        p.style = None;
+    }
+    p
+}
+
+/// An id no control in the document has.
+fn new_id(s: &Session) -> i64 {
+    let mut used = std::collections::BTreeSet::new();
+    let mut add = |bl: &wordcraft_doc::Blocks| {
+        wordcraft_doc::control::walk_controls(bl, &mut |c| {
+            if let Some(id) = c.id {
+                used.insert(id);
+            }
+        })
+    };
+    add(&s.doc.body);
+    for p in s.doc.parts.values() {
+        add(&p.blocks);
+    }
+    let mut id = 1_000_000 + used.len() as i64;
+    while used.contains(&id) {
+        id += 1;
+    }
+    id
+}
+
+// ---------------------------------------------------------------------------------------------
+// Finding the control a command is about
+
+/// The control at `p`, also when `p` is just outside its markers (a click beside a check box).
+fn control_near(s: &Session, at: &Pos) -> Option<ControlRange> {
+    if let Some(r) = s.doc.control_at(at) {
+        return Some(r);
+    }
+    let para = s.doc.para_at(at)?;
+    let w = OBJ.len_utf8();
+    if matches!(para.object_at(at.off), Some(InlineObject::ControlStart { .. })) {
+        return s.doc.control_at(&Pos { off: at.off + w, ..at.clone() });
+    }
+    if at.off >= w && matches!(para.object_at(at.off - w), Some(InlineObject::ControlEnd)) {
+        return s.doc.control_at(&Pos { off: at.off - w, ..at.clone() });
+    }
+    None
+}
+
+/// The control a command acts on: `control` (a tag or title) in the caret's story, else the one
+/// at `at` (a position), else the one at the caret.
+fn target(s: &Session, v: &Value) -> Result<ControlRange, CmdError> {
+    if let Some(name) = p::str(v, "control") {
+        let story = s.sel.focus.story;
+        let stories = std::iter::once(story).chain(std::iter::once(StoryRef::Body));
+        for st in stories {
+            if let Some(r) =
+                s.doc.control_ranges(st).into_iter().filter(|r| r.control.tag == name || r.control.title == name).min_by(|a, b| a.start.cmp(&b.start))
+            {
+                return Ok(r);
+            }
+        }
+        return Err(CmdError::Failed(format!("no content control is called {name:?}")));
+    }
+    let at = v.get("at").and_then(super::parse_pos).unwrap_or_else(|| s.sel.focus.clone());
+    control_near(s, &at).ok_or_else(|| CmdError::Disabled("the selection isn't in a content control".into()))
+}
+
+/// Replace a control's content with `text` (one paragraph's worth) in `props`; returns the end.
+fn set_content(s: &mut Session, r: &ControlRange, text: &str, props: &CharProps) -> Result<Pos, CmdError> {
+    let a = r.content_start();
+    s.doc.delete_range(&a, &r.end)?;
+    let end = s.doc.insert_text(&a, text, props)?;
+    Ok(end)
+}
+
+/// The formatting of a control's content (its first character's), without placeholder styling.
+fn content_base(s: &Session, r: &ControlRange) -> CharProps {
+    let a = r.content_start();
+    let props = s
+        .doc
+        .para_at(&a)
+        .map(|p| if r.is_empty() { p.props_of_char(r.start.off).clone() } else { p.props_of_char(a.off).clone() })
+        .unwrap_or_default();
+    content_props(&props)
+}
+
+// ---------------------------------------------------------------------------------------------
+// Rules for typing and deleting
+
+/// Before text goes in at the selection: refuse what a locked or list-only control doesn't
+/// take; a control showing its placeholder gets the placeholder selected (so it is replaced)
+/// and stops showing it. Returns the formatting the text should get, when it changes.
+pub fn prepare_edit(s: &mut Session) -> Result<Option<CharProps>, CmdError> {
+    if s.sel.is_collapsed() {
+        let at = s.doc.typing_pos(&s.sel.focus);
+        if at != s.sel.focus {
+            s.sel = Selection::caret(at);
+        }
+    }
+    // A caret at the very edge of a control that takes no typing types beside it instead.
+    for _ in 0..16 {
+        if !s.sel.is_collapsed() {
+            break;
+        }
+        let f = s.sel.focus.clone();
+        let Some(r) = s.doc.control_at(&f) else { break };
+        if r.control.lock.can_edit() && r.control.kind.takes_typing() {
+            break;
+        }
+        let w = OBJ.len_utf8();
+        if f == r.end {
+            s.sel = Selection::caret(Pos { off: r.end.off + w, ..r.end.clone() });
+        } else if f == r.content_start() {
+            s.sel = Selection::caret(r.start.clone());
+        } else {
+            break;
+        }
+    }
+    let (a, b) = s.sel.ordered();
+    let Some(r) = s.doc.control_at(&a) else { return Ok(None) };
+    if !r.control.lock.can_edit() {
+        return Err(locked(s, CANT_EDIT));
+    }
+    if !r.control.kind.takes_typing() {
+        let msg = match r.control.kind {
+            ControlKind::CheckBox { .. } => "Click the check box (or use Toggle Check Box) to change it.",
+            ControlKind::DropDown { .. } => "Choose an entry from the list.",
+            _ => "This content control holds a picture.",
+        };
+        return Err(locked(s, msg));
+    }
+    if !r.control.showing_placeholder || !r.contains(&b) {
+        return Ok(None);
+    }
+    let props = content_base(s, &r);
+    s.sel = Selection { anchor: r.content_start(), focus: r.end.clone() };
+    if let Some(c) = s.doc.control_mut(&r.start) {
+        c.showing_placeholder = false;
+    }
+    Ok(Some(props))
+}
+
+/// Enter in a one-line plain text control does nothing.
+pub fn refuses_paragraph(s: &Session) -> bool {
+    s.doc.control_at(&s.sel.focus).is_some_and(|r| {
+        matches!(r.control.kind, ControlKind::Text { multi_line: false } | ControlKind::CheckBox { .. } | ControlKind::DropDown { .. })
+    })
+}
+
+/// Before a deletion of `a..b`: refuse deleting a control that can't be deleted, or editing
+/// content that can't be edited.
+pub fn check_delete(s: &mut Session, a: &Pos, b: &Pos) -> Result<(), CmdError> {
+    if a.story != b.story {
+        return Ok(());
+    }
+    let w = OBJ.len_utf8();
+    let mut refusal = None;
+    for r in s.doc.control_ranges(a.story) {
+        let whole = (&a.path, a.off) <= (&r.start.path, r.start.off) && (&r.end.path, r.end.off + w) <= (&b.path, b.off);
+        let cs = r.content_start();
+        let touches = (&a.path, a.off) < (&r.end.path, r.end.off) && (&b.path, b.off) > (&cs.path, cs.off);
+        if whole && !r.control.lock.can_delete() {
+            refusal = Some(CANT_DELETE);
+            break;
+        }
+        if !whole && touches && !r.control.lock.can_edit() {
+            refusal = Some(CANT_EDIT);
+            break;
+        }
+    }
+    match refusal {
+        Some(m) => Err(locked(s, m)),
+        None => Ok(()),
+    }
+}
+
+/// After the user deleted something: a control left empty shows its placeholder again.
+pub fn restore_placeholder(s: &mut Session) -> Result<(), CmdError> {
+    let at = s.sel.focus.clone();
+    let Some(r) = s.doc.control_at(&at) else { return Ok(()) };
+    if !r.is_empty() || r.control.showing_placeholder {
+        return Ok(());
+    }
+    let text = r.control.placeholder_shown().to_string();
+    if text.is_empty() {
+        return Ok(());
+    }
+    let base = content_base(s, &r);
+    let props = placeholder_props(s, &base);
+    s.doc.insert_text(&r.content_start(), &text, &props)?;
+    if let Some(c) = s.doc.control_mut(&r.start) {
+        c.showing_placeholder = true;
+    }
+    s.sel = Selection::caret(r.content_start());
+    Ok(())
+}
+
+// ---------------------------------------------------------------------------------------------
+// Insert
+
+fn insert(s: &mut Session, v: &Value, kind: ControlKind) -> CmdResult {
+    let mut ctl = ContentControl::new(kind);
+    ctl.id = Some(new_id(s));
+    if let Some(t) = short(v, "title") {
+        ctl.title = t;
+    }
+    if let Some(t) = short(v, "tag") {
+        ctl.tag = t;
+    }
+    match &mut ctl.kind {
+        ControlKind::ComboBox { items, .. } | ControlKind::DropDown { items, .. } => {
+            if let Some(i) = items_param(v) {
+                *items = i;
+            }
+        }
+        ControlKind::Date { format, .. } => {
+            if let Some(f) = short(v, "format").filter(|f| !f.trim().is_empty()) {
+                *format = f;
+            }
+        }
+        ControlKind::CheckBox { checked, .. } => *checked = p::bool(v, "checked").unwrap_or(false),
+        _ => {}
+    }
+    let (a, b) = s.sel.ordered();
+    if a.story != b.story || s.doc.para_at(&a).is_none() || s.doc.para_at(&b).is_none() {
+        return Err(CmdError::Failed("no paragraph at the selection".into()));
+    }
+    if s.doc.control_at(&a).is_some_and(|r| !r.control.lock.can_edit()) {
+        return Err(locked(s, CANT_EDIT));
+    }
+    let whole_para = a.path == b.path && a.off == 0 && s.doc.para_at(&b).is_some_and(|p| !p.is_empty() && b.off == p.len());
+    let block = matches!(ctl.kind, ControlKind::RepeatingSection { .. } | ControlKind::Gallery { .. }) || a.path != b.path || whole_para;
+    if block && matches!(ctl.kind, ControlKind::RichText | ControlKind::RepeatingSection { .. } | ControlKind::Gallery { .. }) {
+        return insert_block(s, ctl, &a, &b);
+    }
+    // An inline control: around the selection (text and pictures), else at the caret with its
+    // placeholder or value.
+    let wraps = a != b && a.path == b.path && matches!(ctl.kind, ControlKind::RichText | ControlKind::Text { .. } | ControlKind::Picture);
+    let base = s.doc.para_at(&a).map(|p| content_props(&p.props_of_char(a.off).clone())).unwrap_or_default();
+    if wraps {
+        s.doc.insert_object(&b, InlineObject::ControlEnd, &base)?;
+        let start = a.clone();
+        s.doc.insert_object(&start, InlineObject::ControlStart { control: Box::new(ctl) }, &base)?;
+        let w = OBJ.len_utf8();
+        s.sel = Selection { anchor: Pos { off: a.off + w, ..a.clone() }, focus: Pos { off: b.off + w, ..b.clone() } };
+        return sel_result(s);
+    }
+    let at = delete_selection(s)?;
+    let at = s.doc.typing_pos(&at);
+    let (text, props) = match &mut ctl.kind {
+        ControlKind::CheckBox { checked, checked_char, unchecked_char, .. } => {
+            ((if *checked { *checked_char } else { *unchecked_char }).to_string(), base.clone())
+        }
+        ControlKind::Date { full_date, format, .. } if p::str(v, "date").is_some() => {
+            let (y, m, d) = p::str(v, "date").and_then(parse_date).ok_or_else(|| CmdError::Params("date: YYYY-MM-DD".into()))?;
+            *full_date = format!("{y:04}-{m:02}-{d:02}T00:00:00Z");
+            (format_date_value(format, y, m, d), base.clone())
+        }
+        _ => {
+            ctl.showing_placeholder = true;
+            let t = ctl.placeholder_shown().to_string();
+            (t, placeholder_props(s, &base))
+        }
+    };
+    let after_start = s.doc.insert_object(&at, InlineObject::ControlStart { control: Box::new(ctl) }, &base)?;
+    let end = s.doc.insert_text(&after_start, &text, &props)?;
+    s.doc.insert_object(&end, InlineObject::ControlEnd, &base)?;
+    s.sel = Selection::caret(after_start);
+    s.goal_x = None;
+    sel_result(s)
+}
+
+/// A block-level control around the paragraphs from `a`'s to `b`'s (same block list).
+fn insert_block(s: &mut Session, mut ctl: ContentControl, a: &Pos, b: &Pos) -> CmdResult {
+    let story = a.story;
+    // Paragraphs in the same block list as `a`'s, up to `b`'s.
+    let last = if b.path.parent() == a.path.parent() { b.path.clone() } else { a.path.clone() };
+    ctl.block = true;
+    let empty = a.path == last && s.doc.para(story, &a.path).is_some_and(|p| p.is_empty());
+    let base = s.doc.para(story, &a.path).map(|p| content_props(&p.props_of_char(0).clone())).unwrap_or_default();
+    let item = matches!(ctl.kind, ControlKind::RepeatingSection { .. }).then(|| {
+        let mut i = ContentControl::new(ControlKind::RepeatingSectionItem);
+        i.block = true;
+        i.id = ctl.id.map(|x| x + 1);
+        i
+    });
+    if empty && !ctl.placeholder_shown().is_empty() {
+        ctl.showing_placeholder = true;
+        let props = placeholder_props(s, &base);
+        let text = ctl.placeholder_shown().to_string();
+        s.doc.insert_text(&Pos::new(story, a.path.clone(), 0), &text, &props)?;
+    }
+    let end_off = s.doc.para(story, &last).map(|p| p.len()).unwrap_or(0);
+    let end_props = s.doc.para(story, &last).map(|p| p.props_at(end_off).clone()).unwrap_or_default();
+    let mut end = Pos::new(story, last.clone(), end_off);
+    if item.is_some() {
+        end = s.doc.insert_object(&end, InlineObject::ControlEnd, &end_props)?;
+    }
+    s.doc.insert_object(&end, InlineObject::ControlEnd, &end_props)?;
+    let mut at = Pos::new(story, a.path.clone(), 0);
+    at = s.doc.insert_object(&at, InlineObject::ControlStart { control: Box::new(ctl) }, &base)?;
+    if let Some(i) = item {
+        at = s.doc.insert_object(&at, InlineObject::ControlStart { control: Box::new(i) }, &base)?;
+    }
+    s.sel = Selection::caret(at);
+    s.goal_x = None;
+    sel_result(s)
+}
+
+// ---------------------------------------------------------------------------------------------
+// Acting on a control
+
+fn design_mode(s: &mut Session, v: &Value) -> CmdResult {
+    s.view.design_mode = p::bool(v, "value").unwrap_or(!s.view.design_mode);
+    Ok(json!({"designMode": s.view.design_mode}))
+}
+
+/// What a command or dialog needs to know about a control.
+pub fn describe(s: &Session, r: &ControlRange) -> Value {
+    let c = &r.control;
+    let mut out = json!({
+        "type": c.kind.name(),
+        "title": c.title,
+        "tag": c.tag,
+        "id": c.id,
+        "lockDelete": !c.lock.can_delete(),
+        "lockEdit": !c.lock.can_edit(),
+        "temporary": c.temporary,
+        "block": c.block,
+        "showingPlaceholder": c.showing_placeholder,
+        "placeholder": c.placeholder_shown(),
+        "text": if c.showing_placeholder { String::new() } else { s.doc.control_text(r) },
+        "start": super::pos_json(&r.start),
+        "end": super::pos_json(&r.end),
+    });
+    match &c.kind {
+        ControlKind::Text { multi_line } => out["multiLine"] = json!(multi_line),
+        ControlKind::CheckBox { checked, checked_char, unchecked_char, .. } => {
+            out["checked"] = json!(checked);
+            out["checkedSymbol"] = json!(checked_char.to_string());
+            out["uncheckedSymbol"] = json!(unchecked_char.to_string());
+        }
+        ControlKind::ComboBox { items, last_value } | ControlKind::DropDown { items, last_value } => {
+            out["items"] = json!(items.iter().map(|i| json!({"display": i.display, "value": i.value()})).collect::<Vec<_>>());
+            out["value"] = json!(last_value);
+        }
+        ControlKind::Date { full_date, format, .. } => {
+            out["date"] = json!(full_date.get(..10).unwrap_or(""));
+            out["format"] = json!(format);
+        }
+        _ => {}
+    }
+    out
+}
+
+fn info(s: &mut Session, v: &Value) -> CmdResult {
+    let r = target(s, v)?;
+    Ok(describe(s, &r))
+}
+
+fn properties(s: &mut Session, v: &Value) -> CmdResult {
+    let r = target(s, v)?;
+    let mut c = r.control.clone();
+    let mut content: Option<String> = None;
+    if let Some(t) = short(v, "title") {
+        c.title = t;
+    }
+    if let Some(t) = short(v, "tag") {
+        c.tag = t;
+    }
+    let (no_delete, no_edit) = (p::bool(v, "lockDelete").unwrap_or(!c.lock.can_delete()), p::bool(v, "lockEdit").unwrap_or(!c.lock.can_edit()));
+    c.lock = ControlLock::from_flags(no_delete, no_edit);
+    if let Some(t) = p::bool(v, "temporary") {
+        c.temporary = t;
+    }
+    if let Some(t) = short(v, "placeholder").filter(|t| !t.trim().is_empty()) {
+        if c.showing_placeholder && t != c.placeholder_shown() {
+            content = Some(t.clone());
+        }
+        c.placeholder_text = t;
+    }
+    match &mut c.kind {
+        ControlKind::Text { multi_line } => {
+            if let Some(m) = p::bool(v, "multiLine") {
+                *multi_line = m;
+            }
+        }
+        ControlKind::ComboBox { items, .. } | ControlKind::DropDown { items, .. } => {
+            if let Some(i) = items_param(v) {
+                *items = i;
+            }
+        }
+        ControlKind::Date { format, full_date, .. } => {
+            if let Some(f) = short(v, "format").filter(|f| !f.trim().is_empty()) {
+                *format = f;
+                // The shown date follows the new format.
+                if let Some((y, m, d)) = parse_date(full_date)
+                    && !c.showing_placeholder
+                {
+                    content = Some(format_date_value(format, y, m, d));
+                }
+            }
+        }
+        ControlKind::CheckBox { checked, checked_char, unchecked_char, .. } => {
+            if let Some(ch) = symbol_param(v, "checkedSymbol") {
+                *checked_char = ch;
+            }
+            if let Some(ch) = symbol_param(v, "uncheckedSymbol") {
+                *unchecked_char = ch;
+            }
+            content = Some((if *checked { *checked_char } else { *unchecked_char }).to_string());
+        }
+        _ => {}
+    }
+    if let Some(text) = content {
+        let base = content_base(s, &r);
+        let props = if c.showing_placeholder { placeholder_props(s, &base) } else { base };
+        set_content(s, &r, &text, &props)?;
+    }
+    if let Some(slot) = s.doc.control_mut(&r.start) {
+        *slot = c;
+    }
+    match s.doc.control_at(&r.content_start()) {
+        Some(r) => Ok(describe(s, &r)),
+        None => sel_result(s),
+    }
+}
+
+fn toggle_check_box(s: &mut Session, v: &Value) -> CmdResult {
+    let r = target(s, v)?;
+    let ControlKind::CheckBox { checked, checked_char, checked_font, unchecked_char, unchecked_font } = &r.control.kind else {
+        return Err(CmdError::Disabled("the selection isn't in a check box".into()));
+    };
+    if !r.control.lock.can_edit() {
+        return Err(locked(s, CANT_EDIT));
+    }
+    let now = p::bool(v, "value").unwrap_or(!checked);
+    let (ch, font) = if now { (*checked_char, checked_font) } else { (*unchecked_char, unchecked_font) };
+    let mut props = content_base(s, &r);
+    if !font.is_empty() {
+        props.font = Some(font.clone());
+    }
+    set_content(s, &r, &ch.to_string(), &props)?;
+    if let Some(c) = s.doc.control_mut(&r.start) {
+        if let ControlKind::CheckBox { checked, .. } = &mut c.kind {
+            *checked = now;
+        }
+        c.showing_placeholder = false;
+    }
+    Ok(json!({"checked": now}))
+}
+
+fn choose_item(s: &mut Session, v: &Value) -> CmdResult {
+    let r = target(s, v)?;
+    let Some(items) = r.control.kind.items() else { return Err(CmdError::Disabled("the selection isn't in a combo box or drop-down list".into())) };
+    if !r.control.lock.can_edit() {
+        return Err(locked(s, CANT_EDIT));
+    }
+    let item = if let Some(i) = p::u64(v, "index") {
+        items.get(usize::try_from(i).unwrap_or(usize::MAX))
+    } else if let Some(val) = p::str(v, "value") {
+        items.iter().find(|i| i.value() == val)
+    } else if let Some(t) = p::str(v, "text") {
+        items.iter().find(|i| i.display == t)
+    } else {
+        return Err(CmdError::Params("give index, value or text".into()));
+    };
+    let Some(item) = item.cloned() else { return Err(CmdError::Params("no such entry".into())) };
+    let props = content_base(s, &r);
+    let end = set_content(s, &r, &item.display, &props)?;
+    if let Some(c) = s.doc.control_mut(&r.start) {
+        if let ControlKind::ComboBox { last_value, .. } | ControlKind::DropDown { last_value, .. } = &mut c.kind {
+            *last_value = item.value().to_string();
+        }
+        c.showing_placeholder = false;
+    }
+    s.sel = Selection::caret(after(&end));
+    Ok(json!({"display": item.display, "value": item.value()}))
+}
+
+fn set_date(s: &mut Session, v: &Value) -> CmdResult {
+    let r = target(s, v)?;
+    let ControlKind::Date { format, .. } = &r.control.kind else { return Err(CmdError::Disabled("the selection isn't in a date picker".into())) };
+    if !r.control.lock.can_edit() {
+        return Err(locked(s, CANT_EDIT));
+    }
+    let (y, m, d) = p::str(v, "date").and_then(parse_date).ok_or_else(|| CmdError::Params("date: YYYY-MM-DD".into()))?;
+    let text = format_date_value(format, y, m, d);
+    let props = content_base(s, &r);
+    let end = set_content(s, &r, &text, &props)?;
+    if let Some(c) = s.doc.control_mut(&r.start) {
+        if let ControlKind::Date { full_date, .. } = &mut c.kind {
+            *full_date = format!("{y:04}-{m:02}-{d:02}T00:00:00Z");
+        }
+        c.showing_placeholder = false;
+    }
+    s.sel = Selection::caret(after(&end));
+    Ok(json!({"date": format!("{y:04}-{m:02}-{d:02}"), "text": text}))
+}
+
+/// Just after the end marker at `end` (the caret leaves a control whose value was chosen).
+fn after(end: &Pos) -> Pos {
+    Pos { off: end.off + OBJ.len_utf8(), ..end.clone() }
+}
+
+fn remove_control(s: &mut Session, v: &Value) -> CmdResult {
+    let r = target(s, v)?;
+    if !r.control.lock.can_delete() {
+        return Err(locked(s, CANT_DELETE));
+    }
+    let w = OBJ.len_utf8();
+    // A placeholder goes with its control; real content stays.
+    if r.control.showing_placeholder {
+        s.doc.delete_range(&r.content_start(), &r.end)?;
+    }
+    let end = s.doc.control_at(&r.content_start()).map(|x| x.end).unwrap_or(r.end.clone());
+    s.doc.para_mut(end.story, &end.path)?.delete(end.off, end.off + w)?;
+    s.doc.para_mut(r.start.story, &r.start.path)?.delete(r.start.off, r.start.off + w)?;
+    s.sel = Selection::caret(s.doc.clamp(&r.start));
+    sel_result(s)
+}
+
+/// A date with a date picture (`M/d/yyyy`, `dddd, MMMM d, yyyy`…).
+pub fn format_date_value(fmt: &str, y: i64, m: u32, d: u32) -> String {
+    super::insert::format_date_parts(fmt, y, m as usize, d, (0, 0, 0), days_from_civil(y, m, d))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn dates_parse_and_format() {
+        assert_eq!(parse_date("2026-10-11"), Some((2026, 10, 11)));
+        assert_eq!(parse_date("2024-02-29T00:00:00Z"), Some((2024, 2, 29)));
+        assert_eq!(parse_date("2025-02-29"), None);
+        assert_eq!(parse_date("20x6-1-1"), None);
+        assert_eq!(parse_date("é"), None);
+        assert_eq!(format_date_value("dddd, MMMM d, yyyy", 2026, 10, 11), "Sunday, October 11, 2026");
+        assert_eq!(format_date_value("M/d/yyyy", 1970, 1, 1), "1/1/1970");
+        assert_eq!(days_from_civil(1970, 1, 1), 0);
+        assert_eq!(super::super::civil_from_days(days_from_civil(2000, 3, 1)), (2000, 3, 1));
+    }
+}
+
+#[cfg(test)]
+mod editing_tests {
+    use serde_json::json;
+    use wordcraft_doc::StoryRef;
+    use wordcraft_doc::control::ControlKind;
+
+    use crate::Session;
+
+    fn run(s: &mut Session, id: &str, v: serde_json::Value) -> serde_json::Value {
+        s.run(id, &v).unwrap_or_else(|e| panic!("{id}: {e}"))
+    }
+    fn text(s: &Session) -> String {
+        s.doc.plain_text(StoryRef::Body)
+    }
+    fn info(s: &mut Session) -> serde_json::Value {
+        run(s, "developer.control", json!({}))
+    }
+
+    #[test]
+    fn typing_replaces_the_placeholder_and_emptying_brings_it_back() {
+        let mut s = Session::new(wordcraft_doc::Document::new());
+        run(&mut s, "text.insert", json!({"text": "Name: "}));
+        run(&mut s, "developer.plainText", json!({"title": "Name", "tag": "name"}));
+        let i = info(&mut s);
+        assert_eq!((i["type"].as_str(), i["showingPlaceholder"].as_bool()), (Some("plainText"), Some(true)));
+        let placeholder = i["placeholder"].as_str().unwrap().to_string();
+        assert_eq!(text(&s), format!("Name: {placeholder}"));
+        // Typing anywhere in the placeholder replaces all of it, in ordinary formatting.
+        run(&mut s, "caret.right", json!({}));
+        run(&mut s, "text.insert", json!({"text": "A"}));
+        run(&mut s, "text.insert", json!({"text": "da"}));
+        assert_eq!(text(&s), "Name: Ada");
+        let i = info(&mut s);
+        assert_eq!((i["showingPlaceholder"].as_bool(), i["text"].as_str()), (Some(false), Some("Ada")));
+        let r = s.doc.control_at(&s.sel.focus).unwrap();
+        let para = s.doc.para_at(&r.content_start()).unwrap();
+        assert_eq!(para.props_of_char(r.content_start().off).style, None, "not placeholder-styled");
+        // Enter in a one-line control does nothing.
+        run(&mut s, "text.newParagraph", json!({}));
+        assert_eq!(s.doc.body.len(), 1);
+        // Deleting all of it shows the placeholder again; Backspace at the content's start keeps the control.
+        for _ in 0..3 {
+            run(&mut s, "text.backspace", json!({}));
+        }
+        assert_eq!(text(&s), format!("Name: {placeholder}"));
+        assert_eq!(info(&mut s)["showingPlaceholder"], true);
+        run(&mut s, "text.backspace", json!({}));
+        assert_eq!(text(&s), format!("Name: {placeholder}"));
+        assert_eq!(s.doc.control_ranges(StoryRef::Body).len(), 1);
+        // Undo goes back through the edits.
+        run(&mut s, "edit.undo", json!({}));
+        run(&mut s, "edit.undo", json!({}));
+        assert_eq!(text(&s), "Name: A");
+        // And the file keeps it.
+        let back = wordcraft_docx::read(&wordcraft_docx::write(&s.doc).unwrap()).unwrap();
+        assert_eq!(back.control_ranges(StoryRef::Body).first().map(|r| r.control.tag.clone()), Some("name".into()));
+    }
+
+    #[test]
+    fn check_boxes_toggle_and_locks_refuse() {
+        let mut s = Session::new(wordcraft_doc::Document::new());
+        run(&mut s, "developer.checkBox", json!({"tag": "ok"}));
+        assert_eq!(text(&s), "\u{2610}");
+        // A check box takes no typing: at its edge the text goes beside it, over it it's refused.
+        run(&mut s, "text.insert", json!({"text": "x"}));
+        assert_eq!(text(&s), "x\u{2610}");
+        run(&mut s, "edit.undo", json!({}));
+        let r = s.doc.control_ranges(StoryRef::Body)[0].clone();
+        s.sel = crate::Selection { anchor: r.content_start(), focus: r.end.clone() };
+        assert!(s.run("text.insert", &json!({"text": "x"})).is_err());
+        assert_eq!(run(&mut s, "developer.toggleCheckBox", json!({}))["checked"], true);
+        assert_eq!(text(&s), "\u{2612}");
+        assert!(matches!(s.doc.control_ranges(StoryRef::Body)[0].control.kind, ControlKind::CheckBox { checked: true, .. }));
+        // Content locked: no toggling.
+        run(&mut s, "developer.properties", json!({"control": "ok", "lockEdit": true}));
+        assert!(s.run("developer.toggleCheckBox", &json!({"control": "ok"})).is_err());
+        assert_eq!(text(&s), "\u{2612}");
+        // Control locked: selecting it whole and deleting is refused, the document unchanged.
+        run(&mut s, "developer.properties", json!({"control": "ok", "lockEdit": false, "lockDelete": true}));
+        run(&mut s, "select.all", json!({}));
+        let before = s.doc.clone();
+        assert!(s.run("text.delete", &json!({})).is_err());
+        assert_eq!(s.doc, before);
+        assert!(s.status.contains("can't be deleted"));
+        // Unlocked, it goes.
+        run(&mut s, "developer.properties", json!({"control": "ok", "lockDelete": false}));
+        run(&mut s, "select.all", json!({}));
+        run(&mut s, "text.delete", json!({}));
+        assert!(s.doc.control_ranges(StoryRef::Body).is_empty());
+    }
+
+    #[test]
+    fn lists_dates_and_blocks() {
+        let mut s = Session::new(wordcraft_doc::Document::new());
+        run(&mut s, "developer.dropDown", json!({"tag": "size", "items": ["Small", {"display": "Large", "value": "L"}]}));
+        run(&mut s, "developer.chooseItem", json!({"control": "size", "value": "L"}));
+        run(&mut s, "text.insert", json!({"text": " on "}));
+        run(&mut s, "developer.datePicker", json!({"tag": "when", "format": "yyyy-MM-dd"}));
+        run(&mut s, "developer.setDate", json!({"control": "when", "date": "2026-10-11"}));
+        assert_eq!(text(&s), "Large on 2026-10-11");
+        assert!(s.run("developer.setDate", &json!({"control": "when", "date": "2026-02-30"})).is_err());
+        // A block control around two paragraphs, and a repeating section.
+        run(&mut s, "text.newParagraph", json!({}));
+        run(&mut s, "text.insert", json!({"text": "Item"}));
+        run(&mut s, "select.all", json!({}));
+        run(&mut s, "developer.richText", json!({"title": "All"}));
+        run(&mut s, "developer.repeatingSection", json!({}));
+        let doc = wordcraft_docx::read(&wordcraft_docx::write(&s.doc).unwrap()).unwrap();
+        let kinds: Vec<_> = doc.control_ranges(StoryRef::Body).iter().map(|r| (r.control.kind.name(), r.control.block)).collect();
+        for k in [("dropDown", false), ("date", false), ("richText", true), ("repeatingSection", true), ("repeatingSectionItem", true)] {
+            assert!(kinds.contains(&k), "{k:?} in {kinds:?}");
+        }
+        assert_eq!(doc.plain_text(StoryRef::Body), s.doc.plain_text(StoryRef::Body));
+    }
+}
diff --git a/crates/engine/src/cmd/draw.rs b/crates/engine/src/cmd/draw.rs
index 38f4121ce3..e9cd535c01 100644
--- a/crates/engine/src/cmd/draw.rs
+++ b/crates/engine/src/cmd/draw.rs
@@ -1,20 +1,28 @@
-//! Draw tab and Review › Ink: pens, the eraser and ink strokes.
+//! Draw tab and Review › Ink: pens, the eraser, the lasso and ink strokes.
 //!
 //! An ink stroke is a floating freeform shape ([`Freeform`] with its pen set) anchored to the
 //! paragraph under where it starts, in front of the text (a highlighter's behind it). The pen
 //! commands only choose what dragging on the page does (session view state); `draw.stroke` and
 //! `draw.erase` change the document.
+//!
+//! Draw › Lasso Select picks the strokes (and drawings) inside a loop drawn on a page; the
+//! selection can then be moved, recoloured, deleted or turned into shapes. Ink to Shape replaces
+//! strokes that look like a line, rectangle, ellipse, triangle or polygon with that shape
+//! ([`ink_shape`](super::ink_shape)). Ink Replay plays the strokes back in the order they were
+//! drawn (each stroke keeps its place in that order). Add Pen keeps custom pens in a gallery.
 
 use std::sync::Arc;
 
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::{Value, json};
-use wordcraft_doc::freeform::{Freeform, InkTool, MAX_INK_PER_PAGE, MAX_POINTS};
+use wordcraft_doc::freeform::{FreePath, Freeform, InkTool, MAX_INK_PER_PAGE, MAX_POINTS};
 use wordcraft_doc::para::{Anchor, Float, InlineObject, OBJ, ShapeKind, Wrap};
 use wordcraft_doc::props::Rgb;
 use wordcraft_doc::{CharProps, Pos, StoryRef};
+use wordcraft_geom::Rect;
 use wordcraft_layout::{DocLayout, Placed};
 
+use super::ink_shape::{InkShape, recognise};
 use super::pos_json;
 use crate::{CmdError, CmdResult, CommandSpec, Session, p};
 
@@ -25,6 +33,8 @@ pub enum DrawMode {
     /// Ordinary selection of text and drawings.
     #[default]
     Select,
+    /// Dragging draws a loop that selects the ink inside it; dragging the selection moves it.
+    Lasso,
     /// Dragging over ink strokes deletes them.
     Eraser,
     /// Dragging draws ink with this pen.
@@ -56,7 +66,69 @@ impl PenSettings {
     }
 }
 
-/// The Draw tab's state: the tool in use and each pen's settings.
+/// A pen added to the pen gallery (Draw › Add Pen): its kind, colour and thickness. Saved as
+/// `{"kind": "pen", "color": "RRGGBB", "width": 1.5}`.
+#[derive(Clone, Copy, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(try_from = "Value", into = "Value")]
+pub struct CustomPen {
+    pub kind: InkTool,
+    pub color: Rgb,
+    /// Points.
+    pub width: f32,
+}
+
+impl TryFrom<Value> for CustomPen {
+    type Error = CmdError;
+    fn try_from(v: Value) -> Result<Self, CmdError> {
+        custom_pen(&v)
+    }
+}
+
+impl From<CustomPen> for Value {
+    fn from(p: CustomPen) -> Value {
+        json!({"kind": p.kind.name(), "color": p.color.hex(), "width": p.width})
+    }
+}
+
+/// Most pens the gallery keeps.
+pub const MAX_PENS: usize = 24;
+
+/// A pen from `{"kind"?, "color"?, "width"?}` (the kind's defaults for what's left out; the
+/// width clamped). Anything but an object, an unknown kind or a malformed colour is refused.
+pub fn custom_pen(v: &Value) -> Result<CustomPen, CmdError> {
+    if !v.is_object() {
+        return Err(CmdError::Params("a pen is {\"kind\", \"color\", \"width\"}".into()));
+    }
+    let kind = match p::str(v, "kind") {
+        Some(k) => InkTool::parse(k).ok_or_else(|| CmdError::Params("`kind` is pen, pencil or highlighter".into()))?,
+        None => InkTool::Pen,
+    };
+    let color = match p::str(v, "color") {
+        Some(c) => Rgb::parse(c).ok_or_else(|| CmdError::Params("`color` is RRGGBB".into()))?,
+        None => kind.default_color(),
+    };
+    let width = p::f32(v, "width").filter(|w| w.is_finite()).unwrap_or(kind.default_width()).clamp(MIN_WIDTH, MAX_WIDTH);
+    Ok(CustomPen { kind, color, width })
+}
+
+/// Read a saved pen gallery, dropping entries that aren't pens (a hand-edited or damaged
+/// settings file loses those pens, never the rest of the settings).
+pub fn lenient_pens<'de, D: Deserializer<'de>>(d: D) -> Result<Vec<CustomPen>, D::Error> {
+    let v = Value::deserialize(d)?;
+    Ok(v.as_array().map(|a| a.iter().filter_map(|x| custom_pen(x).ok()).take(MAX_PENS).collect()).unwrap_or_default())
+}
+
+/// Strokes and drawings picked with the lasso on `page`. Good while the document is as it was
+/// when they were picked (or last moved, recoloured or converted through the lasso).
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct LassoSelection {
+    pub page: usize,
+    pub items: Vec<Pos>,
+    rev: u64,
+}
+
+/// The Draw tab's state: the tool in use, each pen's settings, the pen gallery, Ink to Shape,
+/// the lasso selection and whether ink is being replayed.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct DrawState {
@@ -64,6 +136,16 @@ pub struct DrawState {
     pub pen: PenSettings,
     pub pencil: PenSettings,
     pub highlighter: PenSettings,
+    /// Pens added with Add Pen (kept between runs by the app).
+    #[serde(deserialize_with = "lenient_pens")]
+    pub pens: Vec<CustomPen>,
+    /// Ink to Shape is on: strokes drawn from now on that look like a shape become that shape.
+    pub ink_to_shape: bool,
+    #[serde(skip)]
+    pub lasso: Option<LassoSelection>,
+    /// Ink Replay is showing (the app plays the strokes back and turns this off when done).
+    #[serde(skip)]
+    pub replay: bool,
 }
 
 impl Default for DrawState {
@@ -73,6 +155,10 @@ impl Default for DrawState {
             pen: PenSettings::of(InkTool::Pen),
             pencil: PenSettings::of(InkTool::Pencil),
             highlighter: PenSettings::of(InkTool::Highlighter),
+            pens: Vec::new(),
+            ink_to_shape: false,
+            lasso: None,
+            replay: false,
         }
     }
 }
@@ -99,6 +185,12 @@ const MIN_WIDTH: f32 = 0.25;
 const MAX_WIDTH: f32 = 72.0;
 /// How far from a stroke (beyond its half width) the eraser still takes it, points.
 const ERASE_SLOP: f32 = 3.0;
+/// Most points of a lasso loop that are kept (a longer loop is thinned out).
+const MAX_LASSO_POINTS: usize = 512;
+/// Points of a stroke tested against the lasso (spread along it).
+const LASSO_SAMPLES: usize = 64;
+/// Farthest the lasso moves its selection in one step, points.
+const MAX_MOVE: f32 = 10_000.0;
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
@@ -107,6 +199,12 @@ pub fn specs() -> Vec<CommandSpec> {
             state(s)
         })
         .pure(),
+        CommandSpec::new("draw.lasso", "Lasso Select", "Draw › Tools", lasso)
+            .params(r#"{"page"?: n, "points"?: [[x, y], …], "clear"?: bool}  (no points: use the lasso; points: select the ink inside that loop; clear: drop the selection)"#)
+            .pure(),
+        CommandSpec::new("draw.lassoMove", "Move Selected Ink", "Draw › Tools", lasso_move).params(r#"{"dx": pt, "dy": pt}"#),
+        CommandSpec::new("draw.lassoDelete", "Delete Selected Ink", "Draw › Tools", lasso_delete),
+        CommandSpec::new("draw.lassoColor", "Recolor Selected Ink", "Draw › Tools", lasso_color).params(r#"{"color": "RRGGBB"}"#),
         CommandSpec::new("draw.eraser", "Eraser", "Draw › Tools", |s, v| {
             // With a point, erase there (as a script would); without, pick up the eraser.
             if v.get("page").is_some() || v.get("x").is_some() || v.get("y").is_some() {
@@ -120,10 +218,42 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("draw.pen", "Pen", "Draw › Pens", |s, v| pen(s, v, InkTool::Pen)).params(PEN_PARAMS).pure(),
         CommandSpec::new("draw.pencil", "Pencil", "Draw › Pens", |s, v| pen(s, v, InkTool::Pencil)).params(PEN_PARAMS).pure(),
         CommandSpec::new("draw.highlighter", "Highlighter", "Draw › Pens", |s, v| pen(s, v, InkTool::Highlighter)).params(PEN_PARAMS).pure(),
+        CommandSpec::new("draw.addPen", "Add Pen", "Draw › Pens", add_pen)
+            .params(r#"{"kind"?: "pen|pencil|highlighter", "color"?: "RRGGBB", "width"?: pt}  (adds the pen to the gallery and picks it up)"#)
+            .pure(),
+        CommandSpec::new("draw.removePen", "Remove Pen", "Draw › Pens", |s, v| {
+            let i = p::u64(v, "index").and_then(|i| usize::try_from(i).ok()).ok_or_else(|| CmdError::Params("`index` (0-based) is required".into()))?;
+            if i >= s.view.draw.pens.len() {
+                return Err(CmdError::Params(format!("no pen {i}")));
+            }
+            let pen = s.view.draw.pens.remove(i);
+            Ok(json!({"removed": Value::from(pen), "pens": s.view.draw.pens.len()}))
+        })
+        .params(r#"{"index": n}"#)
+        .pure(),
         CommandSpec::new("draw.stroke", "Draw Ink", "Draw › Pens", stroke).params(
             r#"{"page": n, "points": [[x, y], …] (page points, at most 5000), "tool"?: "pen|pencil|highlighter", "color"?: "RRGGBB", "width"?: pt}"#,
         ),
         CommandSpec::new("draw.erase", "Erase Ink", "Draw › Tools", erase).params(r#"{"page": n, "x": pt, "y": pt}"#),
+        CommandSpec::new("draw.inkToShape", "Ink to Shape", "Draw › Convert", |s, v| {
+            if let Some(on) = p::bool(v, "value") {
+                s.view.draw.ink_to_shape = on;
+                return Ok(json!({"value": on}));
+            }
+            // With strokes lasso-selected it converts them; otherwise it turns the mode on or off.
+            let ink_selected = lasso_selection(s).is_some_and(|l| l.items.iter().any(|pos| s.doc.para_at(pos).and_then(|p| p.object_at(pos.off)).and_then(InlineObject::ink).is_some()));
+            if ink_selected {
+                return s.run("draw.convertInk", &json!({}));
+            }
+            s.view.draw.ink_to_shape = !s.view.draw.ink_to_shape;
+            Ok(json!({"value": s.view.draw.ink_to_shape}))
+        })
+        .params(r#"{"value"?: bool}  (no value: convert the lasso-selected strokes, or turn Ink to Shape on or off)"#)
+        .pure(),
+        CommandSpec::new("draw.convertInk", "Convert to Shapes", "Draw › Convert", convert_selection),
+        CommandSpec::new("draw.replay", "Ink Replay", "Draw › Replay", replay)
+            .params(r#"{"value"?: bool}  (starts or stops Ink Replay; returns the strokes in the order they were drawn)"#)
+            .pure(),
         CommandSpec::new("review.hideInk", "Hide Ink", "Review › Ink", |s, v| {
             s.view.hide_ink = p::bool(v, "value").unwrap_or(!s.view.hide_ink);
             Ok(json!({"value": s.view.hide_ink}))
@@ -146,15 +276,54 @@ fn pen(s: &mut Session, v: &Value, tool: InkTool) -> CmdResult {
     if let Some(c) = color {
         set.color = c;
     }
-    if let Some(w) = p::f32(v, "width") {
+    if let Some(w) = p::f32(v, "width").filter(|w| w.is_finite()) {
         set.width = w.clamp(MIN_WIDTH, MAX_WIDTH);
     }
     s.view.draw.mode = DrawMode::Pen(tool);
     state(s)
 }
 
-/// Ink strokes laid out on `page`: their position, unturned frame, turn and geometry on the page.
-fn ink_on(s: &Session, layout: &DocLayout, page: usize) -> Vec<(Pos, wordcraft_geom::Rect, wordcraft_geom::Spin, Arc<Freeform>, f32)> {
+/// Add a pen to the gallery and pick it up.
+fn add_pen(s: &mut Session, v: &Value) -> CmdResult {
+    let pen = custom_pen(v)?;
+    if s.view.draw.pens.len() >= MAX_PENS {
+        return Err(CmdError::Failed(format!("the pen gallery holds at most {MAX_PENS} pens")));
+    }
+    s.view.draw.pens.push(pen);
+    *s.view.draw.settings_mut(pen.kind) = PenSettings { color: pen.color, width: pen.width };
+    s.view.draw.mode = DrawMode::Pen(pen.kind);
+    Ok(json!({"pen": Value::from(pen), "index": s.view.draw.pens.len() - 1, "pens": s.view.draw.pens.len()}))
+}
+
+/// An ink stroke laid out on a page.
+#[derive(Clone, Debug)]
+pub struct PlacedInk {
+    pub pos: Pos,
+    /// Its unturned frame on the page.
+    pub rect: Rect,
+    /// Its turn about the frame's centre.
+    pub spin: wordcraft_geom::Spin,
+    pub freeform: Arc<Freeform>,
+    pub color: Option<Rgb>,
+    pub width: f32,
+}
+
+impl PlacedInk {
+    /// Its paths in page points, turned as it is drawn.
+    pub fn paths(&self) -> Vec<Vec<[f32; 2]>> {
+        let r = self.rect;
+        let paths = self.freeform.placed(r.x, r.y, r.w, r.h).into_iter().map(|(pts, _)| pts);
+        if self.spin.is_identity() {
+            return paths.collect();
+        }
+        let (cx, cy) = (r.x + r.w / 2.0, r.y + r.h / 2.0);
+        paths.map(|pts| pts.into_iter().map(|[x, y]| <[f32; 2]>::from(self.spin.apply(cx, cy, x, y))).collect()).collect()
+    }
+}
+
+/// Ink strokes laid out on `page`, in the page's drawing order: their position, unturned frame,
+/// turn and geometry on the page.
+pub fn ink_on(s: &Session, layout: &DocLayout, page: usize) -> Vec<PlacedInk> {
     let Some(pg) = layout.pages.get(page) else { return Vec::new() };
     pg.items
         .iter()
@@ -162,8 +331,8 @@ fn ink_on(s: &Session, layout: &DocLayout, page: usize) -> Vec<(Pos, wordcraft_g
             Placed::Object { rect, spin, story, path, off, .. } => {
                 let pos = Pos { story: *story, path: path.clone(), off: *off };
                 match s.doc.para_at(&pos).and_then(|p| p.object_at(*off)) {
-                    Some(InlineObject::Shape { freeform: Some(f), stroke_width, .. }) if f.is_ink() => {
-                        Some((pos, *rect, *spin, f.clone(), *stroke_width))
+                    Some(InlineObject::Shape { freeform: Some(f), stroke_width, stroke, .. }) if f.is_ink() => {
+                        Some(PlacedInk { pos, rect: *rect, spin: *spin, freeform: f.clone(), color: *stroke, width: *stroke_width })
                     }
                     _ => None,
                 }
@@ -179,12 +348,13 @@ pub fn ink_at(s: &mut Session, page: usize, x: f32, y: f32) -> Option<Pos> {
         return None;
     }
     let layout = s.layout();
-    ink_on(s, &layout, page).into_iter().rev().find_map(|(pos, r, spin, f, sw)| {
-        let reach = (if sw.is_finite() { sw.clamp(0.0, MAX_WIDTH) } else { 1.0 }) / 2.0 + ERASE_SLOP;
+    ink_on(s, &layout, page).into_iter().rev().find_map(|k| {
+        let reach = (if k.width.is_finite() { k.width.clamp(0.0, MAX_WIDTH) } else { 1.0 }) / 2.0 + ERASE_SLOP;
         // A turned stroke is drawn turned about its frame's centre: test the point turned back
         // into the stroke's own frame (a turn keeps distances, so the reach holds).
-        let (u, v) = spin.unapply(r.x + r.w / 2.0, r.y + r.h / 2.0, x, y);
-        f.distance(r.x, r.y, r.w, r.h, u, v).filter(|d| *d <= reach).map(|_| pos)
+        let r = k.rect;
+        let (u, v) = k.spin.unapply(r.x + r.w / 2.0, r.y + r.h / 2.0, x, y);
+        k.freeform.distance(r.x, r.y, r.w, r.h, u, v).filter(|d| *d <= reach).map(|_| k.pos)
     })
 }
 
@@ -195,19 +365,55 @@ fn page_param(s: &mut Session, v: &Value) -> Result<(usize, Arc<DocLayout>), Cmd
     Ok((page, layout))
 }
 
+/// `points` as page points: at most `max`, NaN, infinities and malformed entries dropped, each
+/// clamped to the `pw` × `ph` page.
+fn points_param(v: &Value, max: usize, pw: f32, ph: f32) -> Result<Vec<[f32; 2]>, CmdError> {
+    Ok(v.get("points")
+        .and_then(Value::as_array)
+        .ok_or_else(|| CmdError::Params("`points` ([[x, y], …]) is required".into()))?
+        .iter()
+        .take(max)
+        .filter_map(|pt| {
+            let a = pt.as_array()?;
+            let (x, y) = (a.first()?.as_f64()? as f32, a.get(1)?.as_f64()? as f32);
+            (x.is_finite() && y.is_finite()).then(|| [x.clamp(0.0, pw), y.clamp(0.0, ph)])
+        })
+        .collect())
+}
+
 /// Delete the ink stroke under a point.
 fn erase(s: &mut Session, v: &Value) -> CmdResult {
     let (page, _) = page_param(s, v)?;
     let (x, y) = (p::req_f32(v, "x")?, p::req_f32(v, "y")?);
     let pos = ink_at(s, page, x, y).ok_or_else(|| CmdError::Failed("no ink stroke there".into()))?;
+    delete_object(s, &pos)?;
+    Ok(json!({"erased": pos_json(&pos)}))
+}
+
+/// Delete the object at `pos`, keeping the text selection on the same text.
+fn delete_object(s: &mut Session, pos: &Pos) -> Result<(), CmdError> {
     let len = OBJ.len_utf8();
-    s.doc.delete_range(&pos, &Pos { off: pos.off + len, ..pos.clone() })?;
+    s.doc.delete_range(pos, &Pos { off: pos.off + len, ..pos.clone() })?;
     for at in [&mut s.sel.anchor, &mut s.sel.focus] {
         if at.story == pos.story && at.path == pos.path && at.off > pos.off {
             at.off = at.off.saturating_sub(len).max(pos.off);
         }
     }
-    Ok(json!({"erased": pos_json(&pos)}))
+    Ok(())
+}
+
+/// The next stroke's place in the drawing order: one after the latest drawn.
+fn next_order(s: &Session) -> u32 {
+    let latest = s
+        .doc
+        .para_paths(StoryRef::Body)
+        .iter()
+        .filter_map(|path| s.doc.para(StoryRef::Body, path))
+        .flat_map(|p| p.objects.iter())
+        .filter_map(|o| o.ink().and_then(|f| f.order))
+        .max()
+        .unwrap_or(0);
+    latest.saturating_add(1)
 }
 
 /// Draw an ink stroke through page points.
@@ -222,22 +428,10 @@ fn stroke(s: &mut Session, v: &Value) -> CmdResult {
         Some(c) => Rgb::parse(c).ok_or_else(|| CmdError::Params("`color` is RRGGBB".into()))?,
         None => set.color,
     };
-    let width = p::f32(v, "width").unwrap_or(set.width).clamp(MIN_WIDTH, MAX_WIDTH);
+    let width = p::f32(v, "width").filter(|w| w.is_finite()).unwrap_or(set.width).clamp(MIN_WIDTH, MAX_WIDTH);
     let pg = layout.pages.get(page).ok_or_else(|| CmdError::Params(format!("no page {page}")))?;
     let (pw, ph) = (pg.w.max(1.0), pg.h.clamp(1.0, 1e5));
-    // Points on the page; NaN, infinities and malformed entries are dropped.
-    let pts: Vec<[f32; 2]> = v
-        .get("points")
-        .and_then(Value::as_array)
-        .ok_or_else(|| CmdError::Params("`points` ([[x, y], …]) is required".into()))?
-        .iter()
-        .take(MAX_POINTS)
-        .filter_map(|pt| {
-            let a = pt.as_array()?;
-            let (x, y) = (a.first()?.as_f64()? as f32, a.get(1)?.as_f64()? as f32);
-            (x.is_finite() && y.is_finite()).then(|| [x.clamp(0.0, pw), y.clamp(0.0, ph)])
-        })
-        .collect();
+    let pts = points_param(v, MAX_POINTS, pw, ph)?;
     let first = *pts.first().ok_or_else(|| CmdError::Params("`points` has no usable point".into()))?;
     if ink_on(s, &layout, page).len() >= MAX_INK_PER_PAGE {
         return Err(CmdError::Failed(format!("page {page} already has {MAX_INK_PER_PAGE} ink strokes")));
@@ -252,6 +446,7 @@ fn stroke(s: &mut Session, v: &Value) -> CmdResult {
     let (fw, fh) = ((x1 - x0 + width).max(1.0), (y1 - y0 + width).max(1.0));
     let local: Vec<[f32; 2]> = pts.iter().map(|[x, y]| [x - fx, y - fy]).collect();
     let wrap = if tool == InkTool::Highlighter { Wrap::BehindText } else { Wrap::InFrontOfText };
+    let order = next_order(s);
     let obj = InlineObject::Shape {
         kind: ShapeKind::Freeform,
         w: fw,
@@ -261,22 +456,27 @@ fn stroke(s: &mut Session, v: &Value) -> CmdResult {
         stroke_width: width,
         float: Float { wrap, ..Default::default() },
         story: None,
-        freeform: Some(Arc::new(Freeform::ink(tool, fw, fh, local))),
+        freeform: Some(Arc::new(Freeform { order: Some(order), ..Freeform::ink(tool, fw, fh, local) })),
         effects: Default::default(),
+        extra: Default::default(),
     };
     let at = place(s, &layout, obj, page, (fx, fy), first[1])?;
-    Ok(json!({"pos": pos_json(&at), "page": page, "rect": [fx, fy, fw, fh]}))
+    // Ink to Shape: a stroke that looks like a shape becomes it (in the same undo step).
+    let shape = if s.view.draw.ink_to_shape && tool != InkTool::Highlighter { convert_at(s, &at)? } else { None };
+    Ok(json!({"pos": pos_json(&at), "page": page, "rect": [fx, fy, fw, fh], "shape": shape}))
 }
 
 /// Insert floating `obj` with its top-left at `(x, y)` on `page`, anchored to the body paragraph
 /// under `anchor_y` (positioned from its column and top), or, where no paragraph starts on the
 /// page, to the nearest line and positioned on the page. Returns where its character went.
 fn place(s: &mut Session, layout: &DocLayout, obj: InlineObject, page: usize, (x, y): (f32, f32), anchor_y: f32) -> Result<Pos, CmdError> {
-    let (at, on_page) = match super::objects::anchor_paragraph(layout, page, anchor_y) {
+    let (at, on_page) = match super::objects::anchor_paragraph(layout, page, anchor_y, StoryRef::Body) {
         Some(path) => (Pos { story: StoryRef::Body, path, off: 0 }, false),
-        None => {
-            (super::objects::nearest_line(layout, page, anchor_y).ok_or_else(|| CmdError::Params("no text on that page to anchor to".into()))?, true)
-        }
+        None => (
+            super::objects::nearest_line(layout, page, anchor_y, StoryRef::Body)
+                .ok_or_else(|| CmdError::Params("no text on that page to anchor to".into()))?,
+            true,
+        ),
     };
     s.doc.insert_object(&at, obj, &CharProps::default())?;
     let len = OBJ.len_utf8();
@@ -303,12 +503,271 @@ fn place(s: &mut Session, layout: &DocLayout, obj: InlineObject, page: usize, (x
     Ok(at)
 }
 
+// --- Lasso -------------------------------------------------------------------------------
+
+/// The current lasso selection, if the document hasn't changed under it.
+pub fn lasso_selection(s: &Session) -> Option<&LassoSelection> {
+    s.view.draw.lasso.as_ref().filter(|l| l.rev == s.rev() && !l.items.is_empty())
+}
+
+/// Keep `sel` selected after the mutating command running now (which bumps the revision once).
+fn keep_lasso(s: &mut Session, sel: LassoSelection) {
+    s.view.draw.lasso = Some(LassoSelection { rev: s.rev().wrapping_add(1), ..sel });
+}
+
+/// Whether (`x`, `y`) is inside the closed loop `poly` (even–odd rule).
+fn inside(poly: &[[f32; 2]], x: f32, y: f32) -> bool {
+    let n = poly.len();
+    let mut odd = false;
+    for i in 0..n {
+        let (Some(a), Some(b)) = (poly.get(i), poly.get((i + n - 1) % n)) else { continue };
+        if (a[1] > y) != (b[1] > y) && x < (b[0] - a[0]) * (y - a[1]) / (b[1] - a[1]) + a[0] {
+            odd = !odd;
+        }
+    }
+    odd
+}
+
+/// Select the ink inside a loop (most of a stroke's points inside it) and the drawings whose
+/// centre is inside it; without a loop, pick up the lasso.
+fn lasso(s: &mut Session, v: &Value) -> CmdResult {
+    if p::bool(v, "clear") == Some(true) {
+        s.view.draw.lasso = None;
+        return Ok(json!({"selected": [], "count": 0}));
+    }
+    if v.get("points").is_none() {
+        s.view.draw.mode = DrawMode::Lasso;
+        return state(s);
+    }
+    let (page, layout) = page_param(s, v)?;
+    let pg = layout.pages.get(page).ok_or_else(|| CmdError::Params(format!("no page {page}")))?;
+    let mut poly = points_param(v, MAX_POINTS, pg.w.max(1.0), pg.h.clamp(1.0, 1e5))?;
+    if poly.len() > MAX_LASSO_POINTS {
+        let step = poly.len().div_ceil(MAX_LASSO_POINTS);
+        poly = poly.into_iter().step_by(step).collect();
+    }
+    if poly.len() < 3 {
+        return Err(CmdError::Params("a lasso loop needs at least three points".into()));
+    }
+    let mut items = Vec::new();
+    for it in &pg.items {
+        let Placed::Object { rect, spin, story, path, off, .. } = it else { continue };
+        let pos = Pos { story: *story, path: path.clone(), off: *off };
+        let Some(obj) = s.doc.para_at(&pos).and_then(|p| p.object_at(*off)) else { continue };
+        let picked = match obj.ink() {
+            Some(_) if s.view.hide_ink => false,
+            Some(f) => {
+                // Where the stroke is drawn: turned about its frame's centre.
+                let (cx, cy) = (rect.x + rect.w / 2.0, rect.y + rect.h / 2.0);
+                let pts: Vec<[f32; 2]> = f
+                    .placed(rect.x, rect.y, rect.w, rect.h)
+                    .into_iter()
+                    .flat_map(|(p, _)| p)
+                    .map(|[x, y]| <[f32; 2]>::from(spin.apply(cx, cy, x, y)))
+                    .collect();
+                let step = pts.len().div_ceil(LASSO_SAMPLES).max(1);
+                let (n, hits) = pts.iter().step_by(step).fold((0usize, 0usize), |(n, h), [x, y]| (n + 1, h + usize::from(inside(&poly, *x, *y))));
+                n > 0 && hits * 10 >= n * 6
+            }
+            None => obj.frame().is_some() && inside(&poly, rect.x + rect.w / 2.0, rect.y + rect.h / 2.0),
+        };
+        if picked && !items.contains(&pos) {
+            items.push(pos);
+        }
+    }
+    let selected: Vec<Value> = items.iter().map(pos_json).collect();
+    s.view.draw.lasso = (!items.is_empty()).then(|| LassoSelection { page, items, rev: s.rev() });
+    Ok(json!({"page": page, "count": selected.len(), "selected": selected}))
+}
+
+fn lasso_required(s: &Session) -> Result<LassoSelection, CmdError> {
+    lasso_selection(s).cloned().ok_or_else(|| CmdError::Failed("nothing is selected with the lasso".into()))
+}
+
+/// The lasso selection's bounds on its page in `layout` (the document's current layout), for
+/// the app to draw and drag.
+pub fn lasso_bounds(s: &Session, layout: &DocLayout) -> Option<(usize, Rect)> {
+    let sel = lasso_selection(s)?;
+    let mut r: Option<Rect> = None;
+    for pos in &sel.items {
+        if let Some(hit) = layout.object(pos, sel.page) {
+            r = Some(r.map_or(hit.rect, |u| u.union(&hit.rect)));
+        }
+    }
+    r.map(|r| (sel.page, r))
+}
+
+/// Move the lasso-selected drawings by (`dx`, `dy`) points (one undo step).
+fn lasso_move(s: &mut Session, v: &Value) -> CmdResult {
+    let sel = lasso_required(s)?;
+    let d = |k: &str| p::req_f32(v, k).map(|d| if d.is_finite() { d.clamp(-MAX_MOVE, MAX_MOVE) } else { 0.0 });
+    let (dx, dy) = (d("dx")?, d("dy")?);
+    let mut moved = 0;
+    for pos in &sel.items {
+        let para = s.doc.para_mut(pos.story, &pos.path)?;
+        let mut hit = false;
+        if let Some(o) = para.object_at_mut(pos.off)
+            && o.is_floating()
+            && let Some(f) = o.float_mut()
+        {
+            if f.h_align.is_none() {
+                f.x += dx;
+            }
+            if f.v_align.is_none() {
+                f.y += dy;
+            }
+            hit = true;
+        }
+        if hit {
+            para.touch();
+            moved += 1;
+        }
+    }
+    if moved == 0 {
+        return Err(CmdError::Failed("nothing selected can be moved".into()));
+    }
+    keep_lasso(s, sel);
+    Ok(json!({"moved": moved}))
+}
+
+/// Delete the lasso-selected strokes and drawings (one undo step).
+fn lasso_delete(s: &mut Session, _: &Value) -> CmdResult {
+    let mut items = lasso_required(s)?.items;
+    // Last first, so the earlier ones keep their place.
+    items.sort();
+    items.dedup();
+    let mut deleted = 0;
+    for pos in items.iter().rev() {
+        if s.doc.para_at(pos).and_then(|p| p.object_at(pos.off)).is_some() {
+            delete_object(s, pos)?;
+            deleted += 1;
+        }
+    }
+    s.view.draw.lasso = None;
+    if deleted == 0 {
+        return Err(CmdError::Failed("nothing selected to delete".into()));
+    }
+    Ok(json!({"deleted": deleted}))
+}
+
+/// Give the lasso-selected strokes and shapes this outline colour (one undo step).
+fn lasso_color(s: &mut Session, v: &Value) -> CmdResult {
+    let sel = lasso_required(s)?;
+    let color = Rgb::parse(p::req_str(v, "color")?).ok_or_else(|| CmdError::Params("`color` is RRGGBB".into()))?;
+    let mut changed = 0;
+    for pos in &sel.items {
+        let para = s.doc.para_mut(pos.story, &pos.path)?;
+        let mut hit = false;
+        if let Some(InlineObject::Shape { stroke, .. }) = para.object_at_mut(pos.off) {
+            *stroke = Some(color);
+            hit = true;
+        }
+        if hit {
+            para.touch();
+            changed += 1;
+        }
+    }
+    if changed == 0 {
+        return Err(CmdError::Failed("nothing selected has an outline to recolour".into()));
+    }
+    keep_lasso(s, sel);
+    Ok(json!({"recolored": changed, "color": color.hex()}))
+}
+
+// --- Ink to Shape --------------------------------------------------------------------------
+
+/// Turn the lasso-selected strokes that look like shapes into those shapes (one undo step).
+fn convert_selection(s: &mut Session, _: &Value) -> CmdResult {
+    let sel = lasso_required(s)?;
+    let mut converted = Vec::new();
+    for pos in &sel.items {
+        if let Some(name) = convert_at(s, pos)? {
+            converted.push(json!({"pos": pos_json(pos), "shape": name}));
+        }
+    }
+    if converted.is_empty() {
+        return Err(CmdError::Failed("none of the selected strokes looks like a shape".into()));
+    }
+    keep_lasso(s, sel);
+    Ok(json!({"count": converted.len(), "converted": converted}))
+}
+
+/// Replace the ink stroke at `pos` by the shape it looks like, in its colour and thickness and
+/// where it was drawn. `None` (nothing changed) when it isn't a pen or pencil stroke, it is
+/// turned or flipped, or it doesn't look like a shape.
+fn convert_at(s: &mut Session, pos: &Pos) -> Result<Option<&'static str>, CmdError> {
+    let para = s.doc.para_mut(pos.story, &pos.path)?;
+    let Some(InlineObject::Shape { kind, w, h, fill, float, freeform, .. }) = para.object_at_mut(pos.off) else { return Ok(None) };
+    let Some(f) = freeform.as_deref().filter(|f| matches!(f.ink, Some(InkTool::Pen | InkTool::Pencil)) && f.paths.len() == 1) else {
+        return Ok(None);
+    };
+    if float.rot != 0.0 || float.flip_h || float.flip_v {
+        return Ok(None);
+    }
+    // The stroke in its frame's own points (the frame may have been resized since).
+    let Some((pts, _)) = f.placed(0.0, 0.0, *w, *h).into_iter().next() else { return Ok(None) };
+    let Some(found) = recognise(&pts) else { return Ok(None) };
+    let [bx, by, bw, bh] = found.bounds();
+    let (bw, bh) = (bw.max(1.0), bh.max(1.0));
+    let outline = |pts: Vec<[f32; 2]>, closed: bool| {
+        Some(Arc::new(Freeform { w: bw, h: bh, paths: vec![FreePath { pts, closed }], ..Default::default() }.sanitized()))
+    };
+    let local = |c: &[[f32; 2]]| c.iter().map(|[x, y]| [x - bx, y - by]).collect::<Vec<_>>();
+    let (new_kind, geometry) = match &found {
+        InkShape::Rectangle { .. } => (ShapeKind::Rectangle, None),
+        InkShape::Ellipse { .. } => (ShapeKind::Ellipse, None),
+        InkShape::Line { a, b } => (ShapeKind::Freeform, outline(local(&[*a, *b]), false)),
+        InkShape::Polygon(c) => (ShapeKind::Freeform, outline(local(c), true)),
+    };
+    *kind = new_kind;
+    *freeform = geometry;
+    *fill = None;
+    *w = bw;
+    *h = bh;
+    float.x += bx;
+    float.y += by;
+    para.touch();
+    Ok(Some(found.name()))
+}
+
+// --- Ink Replay ----------------------------------------------------------------------------
+
+/// Every ink stroke in the document with its page, in the order it was drawn: strokes that
+/// don't record their order (from other files) first, in document order, then the rest by order.
+pub fn strokes_in_drawing_order(s: &mut Session) -> Vec<(usize, PlacedInk)> {
+    if s.view.hide_ink {
+        return Vec::new();
+    }
+    let layout = s.layout();
+    let mut all: Vec<(usize, PlacedInk)> =
+        (0..layout.pages.len()).flat_map(|page| ink_on(s, &layout, page).into_iter().map(move |k| (page, k))).collect();
+    all.sort_by_key(|(_, k)| k.freeform.order.unwrap_or(0));
+    all
+}
+
+/// Start or stop Ink Replay; the strokes in the order they'll be replayed.
+fn replay(s: &mut Session, v: &Value) -> CmdResult {
+    let on = p::bool(v, "value").unwrap_or(!s.view.draw.replay);
+    let strokes = if on { strokes_in_drawing_order(s) } else { Vec::new() };
+    if on && strokes.is_empty() {
+        return Err(CmdError::Failed("there is no ink to replay".into()));
+    }
+    s.view.draw.replay = on;
+    let list: Vec<Value> = strokes
+        .iter()
+        .map(|(page, k)| {
+            json!({"page": page, "pos": pos_json(&k.pos), "order": k.freeform.order, "tool": k.freeform.ink.map(InkTool::name), "points": k.freeform.paths.iter().map(|p| p.pts.len()).sum::<usize>()})
+        })
+        .collect();
+    Ok(json!({"replaying": on, "strokes": list}))
+}
+
 #[cfg(test)]
 mod tests {
     use serde_json::json;
     use wordcraft_doc::StoryRef;
     use wordcraft_doc::freeform::InkTool;
-    use wordcraft_doc::para::{InlineObject, Wrap};
+    use wordcraft_doc::para::{InlineObject, ShapeKind, Wrap};
 
     use crate::Session;
 
@@ -404,6 +863,20 @@ mod tests {
         assert!(s.run("draw.erase", &json!({"page": 0, "x": 150, "y": 60})).is_err());
     }
 
+    /// The lasso, like the eraser, finds a turned stroke where it is drawn.
+    #[test]
+    fn the_lasso_selects_a_rotated_stroke_where_it_is_drawn() {
+        let mut s = session();
+        s.run("draw.stroke", &json!({"page": 0, "points": [[100, 100], [200, 100]], "width": 2})).unwrap();
+        s.run("select.objects", &json!({"index": 0})).unwrap();
+        s.run("arrange.rotation", &json!({"degrees": 90})).unwrap();
+        // A loop around its old horizontal path misses it; one around the vertical stroke takes it.
+        let r = s.run("draw.lasso", &json!({"page": 0, "points": [[90, 95], [210, 95], [210, 105], [90, 105]]})).unwrap();
+        assert_eq!(r["count"], 0);
+        let r = s.run("draw.lasso", &json!({"page": 0, "points": [[140, 40], [160, 40], [160, 160], [140, 160]]})).unwrap();
+        assert_eq!(r["count"], 1);
+    }
+
     /// `draw.eraser` is a view command, but with a point it erases through `draw.erase`, which
     /// changes the document: that must be one undo step and mark the document changed.
     #[test]
@@ -421,4 +894,127 @@ mod tests {
         s.run("edit.redo", &json!({})).unwrap();
         assert!(ink(&s).is_empty());
     }
+
+    /// A closed rectangle drawn as page points, `per` points to a side.
+    fn rect_stroke(x: f32, y: f32, w: f32, h: f32) -> Vec<[f32; 2]> {
+        let c = [[x, y], [x + w, y], [x + w, y + h], [x, y + h]];
+        let mut pts = Vec::new();
+        for i in 0..4 {
+            let (a, b) = (c[i], c[(i + 1) % 4]);
+            for k in 0..10 {
+                let t = k as f32 / 10.0;
+                pts.push([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
+            }
+        }
+        pts.push([x, y]);
+        pts
+    }
+
+    #[test]
+    fn the_lasso_selects_the_ink_inside_and_moves_recolours_and_deletes_it() {
+        let mut s = session();
+        s.run("draw.stroke", &json!({"page": 0, "points": [[100, 100], [140, 110]]})).unwrap();
+        s.run("draw.stroke", &json!({"page": 0, "points": [[300, 300], [340, 310]]})).unwrap();
+        // Without points it picks up the lasso; a loop around the first stroke selects only it.
+        s.run("draw.lasso", &json!({})).unwrap();
+        assert_eq!(s.view.draw.mode, super::DrawMode::Lasso);
+        let r = s.run("draw.lasso", &json!({"page": 0, "points": [[80, 80], [200, 80], [200, 150], [80, 150]]})).unwrap();
+        assert_eq!(r["count"], 1);
+        let before = s.layout().object(&super::lasso_selection(&s).unwrap().items[0], 0).unwrap().rect;
+        // Moved, recoloured: each one undo step, and the selection stays.
+        let steps = s.undo_depth();
+        s.run("draw.lassoMove", &json!({"dx": 20, "dy": -10})).unwrap();
+        s.run("draw.lassoColor", &json!({"color": "0070C0"})).unwrap();
+        assert_eq!(s.undo_depth(), steps + 2);
+        let sel = super::lasso_selection(&s).unwrap().items[0].clone();
+        let after = s.layout().object(&sel, 0).unwrap().rect;
+        assert!((after.x - before.x - 20.0).abs() < 0.01 && (after.y - before.y + 10.0).abs() < 0.01, "{before:?} -> {after:?}");
+        let objs = ink(&s);
+        let blue = objs.iter().filter(|o| matches!(o, InlineObject::Shape { stroke: Some(c), .. } if c.hex() == "0070C0")).count();
+        assert_eq!(blue, 1);
+        // Deleted: only the selected stroke goes, and the selection with it.
+        s.run("draw.lassoDelete", &json!({})).unwrap();
+        assert_eq!(ink(&s).len(), 1);
+        assert!(super::lasso_selection(&s).is_none());
+        assert!(s.run("draw.lassoMove", &json!({"dx": 1, "dy": 1})).is_err(), "nothing selected");
+        // Hostile loops are refused or select nothing; they never panic.
+        assert!(s.run("draw.lasso", &json!({"page": 0, "points": [[1, 1], [2, 2]]})).is_err());
+        let huge: Vec<[f64; 2]> = (0..20_000).map(|i| [(i % 600) as f64, (i / 40) as f64]).collect();
+        let _ = s.run("draw.lasso", &json!({"page": 0, "points": huge}));
+    }
+
+    #[test]
+    fn ink_to_shape_turns_shape_like_strokes_into_shapes_and_leaves_scribbles() {
+        let mut s = session();
+        assert_eq!(s.run("draw.inkToShape", &json!({})).unwrap()["value"], true);
+        let steps = s.undo_depth();
+        let r = s.run("draw.stroke", &json!({"page": 0, "points": rect_stroke(100.0, 100.0, 120.0, 60.0), "color": "C00000", "width": 2})).unwrap();
+        assert_eq!(r["shape"], "rectangle");
+        assert_eq!(s.undo_depth(), steps + 1, "drawn and converted in one undo step");
+        let at: wordcraft_doc::Pos = serde_json::from_value(r["pos"].clone()).unwrap();
+        let obj = s.doc.para_at(&at).and_then(|p| p.object_at(at.off)).cloned().unwrap();
+        let InlineObject::Shape { kind, w, h, stroke, stroke_width, freeform, .. } = obj else { panic!("{obj:?}") };
+        assert_eq!((kind, stroke, stroke_width, freeform.is_none()), (ShapeKind::Rectangle, Some(wordcraft_doc::Rgb(0xC0, 0, 0)), 2.0, true));
+        assert!((w - 120.0).abs() < 2.0 && (h - 60.0).abs() < 2.0, "{w} x {h}");
+        let rect = s.layout().object(&at, 0).unwrap().rect;
+        assert!((rect.x - 100.0).abs() < 2.0 && (rect.y - 100.0).abs() < 2.0, "where it was drawn: {rect:?}");
+        // A scribble stays ink.
+        let r = s.run("draw.stroke", &json!({"page": 0, "points": [[300, 300], [320, 340], [340, 300], [360, 340], [380, 300]]})).unwrap();
+        assert!(r["shape"].is_null());
+        assert_eq!(ink(&s).len(), 1);
+        // Off again; a drawn ellipse stays ink until the lasso selects it and Ink to Shape converts it.
+        s.run("draw.inkToShape", &json!({"value": false})).unwrap();
+        let ring: Vec<[f32; 2]> =
+            (0..=48).map(|i| i as f32 / 48.0 * std::f32::consts::TAU).map(|a| [200.0 + 50.0 * a.cos(), 500.0 + 30.0 * a.sin()]).collect();
+        s.run("draw.stroke", &json!({"page": 0, "points": ring})).unwrap();
+        assert_eq!(ink(&s).len(), 2);
+        s.run("draw.lasso", &json!({"page": 0, "points": [[130, 450], [270, 450], [270, 550], [130, 550]]})).unwrap();
+        let r = s.run("draw.inkToShape", &json!({})).unwrap();
+        assert_eq!(r["converted"][0]["shape"], "ellipse");
+        assert_eq!(ink(&s).len(), 1);
+        assert!(!s.view.draw.ink_to_shape, "converting the selection doesn't turn the mode on");
+    }
+
+    #[test]
+    fn ink_replay_plays_strokes_in_the_order_they_were_drawn() {
+        let mut s = session();
+        // Drawn low on the page first, then higher: document order would be the other way round.
+        s.run("draw.stroke", &json!({"page": 0, "points": [[100, 400], [150, 400]]})).unwrap();
+        s.run("draw.stroke", &json!({"page": 0, "points": [[100, 90], [150, 90]]})).unwrap();
+        let r = s.run("draw.replay", &json!({})).unwrap();
+        assert!(s.view.draw.replay);
+        let orders: Vec<u64> = r["strokes"].as_array().unwrap().iter().map(|k| k["order"].as_u64().unwrap()).collect();
+        assert_eq!(orders, vec![1, 2]);
+        let ys: Vec<f32> = super::strokes_in_drawing_order(&mut s).iter().map(|(_, k)| k.rect.y).collect();
+        assert!(ys[0] > ys[1], "the lower stroke was drawn first: {ys:?}");
+        assert_eq!(s.run("draw.replay", &json!({})).unwrap()["replaying"], false);
+        // Nothing to replay without ink.
+        assert!(session().run("draw.replay", &json!({})).is_err());
+    }
+
+    #[test]
+    fn add_pen_validates_and_saved_galleries_drop_junk() {
+        let mut s = session();
+        let r = s.run("draw.addPen", &json!({"kind": "highlighter", "color": "00B050", "width": 1e9})).unwrap();
+        assert_eq!(r["pen"], json!({"kind": "highlighter", "color": "00B050", "width": super::MAX_WIDTH}));
+        assert_eq!(s.view.draw.mode, super::DrawMode::Pen(InkTool::Highlighter), "the new pen is picked up");
+        for bad in [json!({"kind": "crayon"}), json!({"color": "blue"}), json!(5), json!(null)] {
+            assert!(s.run("draw.addPen", &bad).is_err(), "{bad}");
+        }
+        for _ in 0..super::MAX_PENS + 3 {
+            let _ = s.run("draw.addPen", &json!({}));
+        }
+        assert_eq!(s.view.draw.pens.len(), super::MAX_PENS);
+        s.run("draw.removePen", &json!({"index": 0})).unwrap();
+        assert!(s.run("draw.removePen", &json!({"index": 999})).is_err());
+        // A saved gallery keeps its pens and drops the junk around them.
+        let saved =
+            json!({"pens": [{"kind": "pencil", "color": "7030A0", "width": 3}, "junk", {"kind": "crayon"}, {"width": "x"}], "inkToShape": true});
+        let d: super::DrawState = serde_json::from_value(saved).unwrap();
+        assert_eq!(d.pens.len(), 2);
+        assert_eq!((d.pens[0].kind, d.pens[0].color.hex(), d.pens[0].width), (InkTool::Pencil, "7030A0".to_string(), 3.0));
+        assert!(d.ink_to_shape);
+        let back: super::DrawState = serde_json::from_value(serde_json::to_value(&d).unwrap()).unwrap();
+        assert_eq!(back.pens, d.pens);
+    }
 }
diff --git a/crates/engine/src/cmd/edit.rs b/crates/engine/src/cmd/edit.rs
index 08f68d70f6..e7243a33fe 100644
--- a/crates/engine/src/cmd/edit.rs
+++ b/crates/engine/src/cmd/edit.rs
@@ -4,7 +4,7 @@ use serde_json::{Value, json};
 use wordcraft_doc::edit::Fragment;
 use wordcraft_doc::{Pos, StoryRef};
 
-use super::{delete_selection, pos_json, sel_result};
+use super::{delete_selection, find_pattern, pos_json, sel_result};
 use crate::{CmdError, CmdResult, CommandSpec, Selection, Session, p};
 
 fn has_sel(s: &Session) -> Option<&'static str> {
@@ -14,12 +14,18 @@ fn has_sel(s: &Session) -> Option<&'static str> {
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         CommandSpec::new("edit.undo", "Undo", "Quick Access Toolbar", |s, _| {
+            if s.step_lifts_protection(false) {
+                return Err(CmdError::Disabled("edit.undo: use Stop Protection to lift the document's protection".into()));
+            }
             s.undo();
             sel_result(s)
         })
         .key("Mod+Z")
         .pure(),
         CommandSpec::new("edit.redo", "Redo", "Quick Access Toolbar", |s, _| {
+            if s.step_lifts_protection(true) {
+                return Err(CmdError::Disabled("edit.redo: use Stop Protection to lift the document's protection".into()));
+            }
             s.redo();
             sel_result(s)
         })
@@ -59,19 +65,29 @@ pub fn specs() -> Vec<CommandSpec> {
         .pure(),
         CommandSpec::new("edit.find", "Find", "Home › Editing", find)
             .key("Mod+F")
-            .params(r#"{"text": string, "matchCase"?: bool, "wholeWord"?: bool, "regex"?: bool}"#)
+            .params(r#"{"text": string, "matchCase"?: bool, "wholeWord"?: bool, "matchPrefix"?: bool, "matchSuffix"?: bool, "ignorePunct"?: bool, "ignoreSpace"?: bool, "wildcards"?: bool, "special"?: bool (^p ^t ^# … codes, default true), "regex"?: bool}"#)
             .pure(),
         CommandSpec::new("edit.advancedFind", "Advanced Find", "Home › Editing › Find", advanced_find)
-            .params(r#"{"text"?: string, "matchCase"?: bool, "wholeWord"?: bool, "regex"?: bool, "in"?: "main|selection", "highlight"?: bool}"#)
+            .params(r#"{"text"?: string, …options of edit.find, "in"?: "main|selection", "highlight"?: bool}"#)
             .pure(),
-        CommandSpec::new("edit.findNext", "Find Next", "Home › Editing › Find", |s, _| step(s, 1)).key("Mod+G / F3 / Mod+PageDown").pure(),
-        CommandSpec::new("edit.findPrevious", "Find Previous", "Home › Editing › Find", |s, _| step(s, -1))
-            // Elsewhere Ctrl+Shift+G is Word Count; Ctrl+Page Up/Down browse the find results.
-            .key(super::mac_or("Mod+Shift+G / Mod+PageUp", "Mod+PageUp"))
-            .pure(),
-        CommandSpec::new("edit.replace", "Replace", "Home › Editing", replace).key("Mod+H").params(r#"{"text": string, "with": string}"#),
+        CommandSpec::new("edit.findNext", "Find Next", "Home › Editing › Find", |s, v| {
+            read_opts(s, v);
+            step(s, 1)
+        })
+        .key("Mod+G / F3 / Mod+PageDown")
+        .params(r#"{"text"?: string, "matchCase"?: bool, "wholeWord"?: bool, "regex"?: bool}"#)
+        .pure(),
+        CommandSpec::new("edit.findPrevious", "Find Previous", "Home › Editing › Find", |s, v| {
+            read_opts(s, v);
+            step(s, -1)
+        })
+        // Elsewhere Ctrl+Shift+G is Word Count; Ctrl+Page Up/Down browse the find results.
+        .key(super::mac_or("Mod+Shift+G / Mod+PageUp", "Mod+PageUp"))
+        .params(r#"{"text"?: string, "matchCase"?: bool, "wholeWord"?: bool, "regex"?: bool}"#)
+        .pure(),
+        CommandSpec::new("edit.replace", "Replace", "Home › Editing", replace).key("Mod+H").params(r#"{"text": string, "with": string, …options of edit.replaceAll}"#),
         CommandSpec::new("edit.replaceAll", "Replace All", "Home › Editing › Replace", replace_all)
-            .params(r#"{"text": string, "with": string, "matchCase"?: bool, "wholeWord"?: bool, "regex"?: bool}"#),
+            .params(r#"{"text": string, "with": string (^p ^t ^& ^c …; \\1 with wildcards), …options of edit.find}"#),
         CommandSpec::new("edit.goto", "Go To", "Home › Editing › Find", goto)
             .key("Mod+Alt+G / F5")
             .params(r#"{"page"?: n, "bookmark"?: string, "paragraph"?: n}"#)
@@ -113,6 +129,7 @@ fn cut(s: &mut Session, v: &Value) -> CmdResult {
     if !super::moves::cut_tracked(s)? {
         delete_selection(s)?;
     }
+    super::controls::restore_placeholder(s)?;
     Ok(r)
 }
 
@@ -267,50 +284,157 @@ fn paste_text(s: &mut Session, v: &Value) -> CmdResult {
         Some(t) => t.to_string(),
         None => s.clipboard.as_ref().map(Fragment::plain_text).unwrap_or_default(),
     };
-    super::type_text(s, &text.replace("\r\n", "\r").replace('\n', "\r"))?;
+    super::paste_text(s, &text.replace("\r\n", "\r").replace('\n', "\r"))?;
     sel_result(s)
 }
 
+/// One match: its range and, when asked for, the Replace with text filled in for it.
+pub(crate) struct Found {
+    pub a: Pos,
+    pub b: Pos,
+    pub rep: Option<String>,
+}
+
+/// A stretch of searched text: `len` bytes from `hay` are paragraph `para`'s bytes from `raw`.
+/// A paragraph mark is a one-byte stretch at the paragraph's end (`mark`).
+struct Seg {
+    hay: usize,
+    para: usize,
+    raw: usize,
+    len: usize,
+    mark: bool,
+}
+
 /// All matches of the find state in the current story. Text marked deleted by
 /// Track Changes is no longer part of the document, so the search reads each
 /// paragraph without it: a match lies within one stretch of live text, and word
 /// boundaries and anchors see the neighbouring live text, not the deleted text.
 /// Otherwise Replace would find its own deleted text again.
 pub(crate) fn search(s: &Session, story: StoryRef) -> Result<Vec<(Pos, Pos)>, CmdError> {
+    Ok(search_full(s, story, false)?.into_iter().map(|f| (f.a, f.b)).collect())
+}
+
+fn find_opts(f: &crate::session::FindState) -> find_pattern::Opts {
+    find_pattern::Opts {
+        match_case: f.match_case,
+        whole_word: f.whole_word,
+        prefix: f.match_prefix,
+        suffix: f.match_suffix,
+        ignore_punct: f.ignore_punct,
+        ignore_space: f.ignore_space,
+        wildcards: f.wildcards,
+        regex: f.regex,
+        literal: f.literal,
+    }
+}
+
+/// [`search`], with the Replace with text of each match when `with_rep` (special codes, `^&`,
+/// wildcard groups). A pattern that can match a paragraph mark (`^p`) reads runs of sibling
+/// paragraphs as one text with a mark between them; otherwise each paragraph is read alone.
+pub(crate) fn search_full(s: &Session, story: StoryRef, with_rep: bool) -> Result<Vec<Found>, CmdError> {
     use regex_automata::{Input, meta, util::syntax};
     let f = &s.find;
     if f.query.is_empty() {
         return Ok(Vec::new());
     }
-    let pat = if f.regex { f.query.clone() } else { regex::escape(&f.query) };
-    let pat = if f.whole_word { format!(r"\b{pat}\b") } else { pat };
+    let opts = find_opts(f);
+    let c = find_pattern::compile(&f.query, &opts).map_err(CmdError::Params)?;
     let re = meta::Regex::builder()
-        .syntax(syntax::Config::new().case_insensitive(!f.match_case))
+        .syntax(syntax::Config::new().case_insensitive(c.case_insensitive))
         .configure(meta::Config::new().nfa_size_limit(Some(1 << 20)))
-        .build(&pat)
+        .build(&c.pattern)
         .map_err(|e| CmdError::Params(format!("bad pattern: {e}")))?;
-    let mut out = Vec::new();
-    for path in s.doc.para_paths(story) {
-        let Some(p) = s.doc.para(story, &path) else { continue };
-        // The paragraph as it reads, and its stretches of live text as
-        // (start in `live`, start in the paragraph, length).
-        let mut live = String::new();
-        let mut spans: Vec<(usize, usize, usize)> = Vec::new();
-        for (r, c) in p.run_ranges() {
-            let Some(t) = p.text.get(r.clone()).filter(|_| c.del.is_none()) else { continue };
-            match spans.last_mut() {
-                Some((_, raw, n)) if *raw + *n == r.start => *n += t.len(),
-                _ => spans.push((live.len(), r.start, t.len())),
-            }
-            live.push_str(t);
+    let pieces = with_rep.then(|| find_pattern::parse_replace(&f.replace, &opts));
+    let paths = s.doc.para_paths(story);
+    // Paragraphs read as one text: consecutive siblings when the pattern spans paragraphs.
+    let mut chunks: Vec<std::ops::Range<usize>> = Vec::new();
+    for i in 0..paths.len() {
+        let joins =
+            c.spans_paras && i > 0 && paths.get(i - 1).zip(paths.get(i)).is_some_and(|(x, y)| x.parent() == y.parent() && x.last() + 1 == y.last());
+        match chunks.last_mut() {
+            Some(r) if joins => r.end = i + 1,
+            _ => chunks.push(i..i + 1),
         }
-        for (at, raw, n) in spans {
-            for m in re.find_iter(Input::new(&live).range(at..at + n)) {
+    }
+    let mut out = Vec::new();
+    let mut caps = re.create_captures();
+    for chunk in chunks {
+        let mut hay = String::new();
+        let mut segs: Vec<Seg> = Vec::new();
+        // Where the live text breaks (tracked-deleted text, or a paragraph edge when not spanning).
+        let mut cuts: Vec<usize> = Vec::new();
+        let last = chunk.end.saturating_sub(1);
+        for i in chunk {
+            let Some(p) = paths.get(i).and_then(|path| s.doc.para(story, path)) else {
+                cuts.push(hay.len());
+                continue;
+            };
+            let mut expect = 0;
+            for (r, ch) in p.run_ranges() {
+                let Some(t) = p.text.get(r.clone()).filter(|_| ch.del.is_none()) else { continue };
+                if t.is_empty() {
+                    continue;
+                }
+                if r.start != expect {
+                    cuts.push(hay.len());
+                }
+                match segs.last_mut() {
+                    Some(sg) if !sg.mark && sg.para == i && sg.raw + sg.len == r.start => sg.len += t.len(),
+                    _ => segs.push(Seg { hay: hay.len(), para: i, raw: r.start, len: t.len(), mark: false }),
+                }
+                hay.push_str(t);
+                expect = r.end;
+            }
+            if i < last {
+                if expect != p.text.len() {
+                    cuts.push(hay.len());
+                }
+                segs.push(Seg { hay: hay.len(), para: i, raw: p.text.len(), len: 1, mark: true });
+                hay.push(if p.section.is_some() { find_pattern::SECT_MARK } else { find_pattern::PARA_MARK });
+            }
+        }
+        let pos_of = |x: usize, end: bool| -> Option<Pos> {
+            let k = segs.partition_point(|sg| if end { sg.hay + sg.len < x } else { sg.hay + sg.len <= x });
+            let sg = segs.get(k)?;
+            if (end && sg.hay >= x) || (!end && sg.hay > x) {
+                return None;
+            }
+            if sg.mark && x > sg.hay {
+                let path = paths.get(sg.para)?;
+                return Some(Pos { story, path: path.with_last(path.last() + 1), off: 0 });
+            }
+            Some(Pos { story, path: paths.get(sg.para)?.clone(), off: sg.raw + (x - sg.hay) })
+        };
+        cuts.push(hay.len());
+        let mut from = 0;
+        for cut in cuts {
+            if cut <= from {
+                continue;
+            }
+            let mut input = Input::new(&hay).range(from..cut);
+            from = cut;
+            loop {
+                re.search_captures(&input, &mut caps);
+                let Some(m) = caps.get_match() else { break };
+                // Step past an empty match so the search moves on.
+                let next = if m.is_empty() {
+                    hay.get(m.end()..).and_then(|t| t.chars().next()).map_or(m.end() + 1, |c| m.end() + c.len_utf8())
+                } else {
+                    m.end()
+                };
+                if next > input.end() {
+                    break;
+                }
+                input.set_start(next);
                 if m.is_empty() {
                     continue;
                 }
-                let (a, b) = (raw + m.start().saturating_sub(at), raw + m.end().saturating_sub(at));
-                out.push((Pos { story, path: path.clone(), off: a }, Pos { story, path: path.clone(), off: b }));
+                let (Some(a), Some(b)) = (pos_of(m.start(), false), pos_of(m.end(), true)) else { continue };
+                let rep = pieces.as_ref().map(|pc| {
+                    let group = |n: usize| caps.get_group(n).and_then(|g| hay.get(g.range())).map(str::to_string);
+                    find_pattern::expand(pc, hay.get(m.range()).unwrap_or(""), &group, &s.clipboard_text)
+                });
+                out.push(Found { a, b, rep });
                 if out.len() >= 100_000 {
                     return Ok(out);
                 }
@@ -335,6 +459,24 @@ fn read_opts(s: &mut Session, v: &Value) {
     if let Some(b) = p::bool(v, "regex") {
         s.find.regex = b;
     }
+    if let Some(b) = p::bool(v, "wildcards") {
+        s.find.wildcards = b;
+    }
+    if let Some(b) = p::bool(v, "special") {
+        s.find.literal = !b;
+    }
+    if let Some(b) = p::bool(v, "matchPrefix") {
+        s.find.match_prefix = b;
+    }
+    if let Some(b) = p::bool(v, "matchSuffix") {
+        s.find.match_suffix = b;
+    }
+    if let Some(b) = p::bool(v, "ignorePunct") {
+        s.find.ignore_punct = b;
+    }
+    if let Some(b) = p::bool(v, "ignoreSpace") {
+        s.find.ignore_space = b;
+    }
     if let Some(t) = p::str(v, "with") {
         s.find.replace = t.to_string();
     }
@@ -414,34 +556,41 @@ fn step(s: &mut Session, dir: i64) -> CmdResult {
 fn replace(s: &mut Session, v: &Value) -> CmdResult {
     read_opts(s, v);
     let story = s.sel.focus.story;
-    let results = search(s, story)?;
+    let results = search_full(s, story, true)?;
     let (a, b) = s.sel.ordered();
     // Replace the current match if selected, then move to the next.
-    if results.iter().any(|(x, y)| *x == a && *y == b) {
-        let with = s.find.replace.clone();
-        super::type_text(s, &with)?;
+    if let Some(f) = results.into_iter().find(|f| f.a == a && f.b == b) {
+        super::paste_text(s, &f.rep.unwrap_or_default())?;
     }
     let _ = step(s, 1);
     Ok(json!({"remaining": search(s, story)?.len()}))
 }
 
+/// Every match replaced, last first so earlier positions stay valid (one undo step). A `\r` in
+/// the replacement (`^p`) splits the paragraph.
 fn replace_all(s: &mut Session, v: &Value) -> CmdResult {
     read_opts(s, v);
     let story = s.sel.focus.story;
-    let results = search(s, story)?;
-    let with = s.find.replace.clone();
+    let results = search_full(s, story, true)?;
     let n = results.len();
-    // Replace from the end so earlier positions stay valid.
-    for (a, b) in results.into_iter().rev() {
+    for Found { a, b, rep } in results.into_iter().rev() {
+        let with = rep.unwrap_or_default();
         if s.doc.settings.track_changes {
             // Same path as a single replace, so the change is a reviewable revision.
             s.sel = Selection { anchor: a, focus: b };
-            super::type_text(s, &with)?;
+            super::paste_text(s, &with)?;
             continue;
         }
         let props = s.doc.para_at(&a).map(|p| p.props_of_char(a.off).clone()).unwrap_or_default();
-        s.doc.delete_range(&a, &b)?;
-        s.doc.insert_text(&a, &with, &props)?;
+        let mut at = s.doc.delete_range(&a, &b)?;
+        for (k, part) in with.split(['\r', '\u{2029}']).enumerate() {
+            if k > 0 {
+                at = s.doc.split_paragraph(&at)?;
+            }
+            if !part.is_empty() {
+                at = s.doc.insert_text(&at, part, &props)?;
+            }
+        }
     }
     s.status = format!("All done. We made {n} replacements.");
     Ok(json!({"replaced": n}))
diff --git a/crates/engine/src/cmd/file.rs b/crates/engine/src/cmd/file.rs
index ee8122e3d7..473cf0b092 100644
--- a/crates/engine/src/cmd/file.rs
+++ b/crates/engine/src/cmd/file.rs
@@ -12,7 +12,7 @@ pub const MAX_AUTHOR_CHARS: usize = 255;
 /// Sets the user name that new tracked changes and comments are recorded under. The name is
 /// trimmed, stripped of control characters (they can't go into the saved XML) and cut to
 /// [`MAX_AUTHOR_CHARS`]; a blank name is refused so revisions always carry an author.
-fn set_author(s: &mut Session, v: &Value) -> CmdResult {
+pub(crate) fn set_author(s: &mut Session, v: &Value) -> CmdResult {
     let name: String = p::req_str(v, "name")?.trim().chars().filter(|c| !c.is_control()).take(MAX_AUTHOR_CHARS).collect();
     let name = name.trim_end();
     if name.is_empty() {
@@ -35,9 +35,9 @@ pub fn specs() -> Vec<CommandSpec> {
             .pure(),
         CommandSpec::new("file.save", "Save", "File", save)
             .key("Mod+S / Shift+F12")
-            .params(r#"{"path"?: string, "password"?: string (encrypt this and later saves with it, as file.encrypt does)}"#)
+            .params(r#"{"path"?: string, "password"?: string (encrypt this and later saves with it, as file.encrypt does), "markup"?: bool (Print Markup for a PDF, PNG, HTML, Markdown or text copy: comments shown; default file.printMarkup)}"#)
             .pure(),
-        CommandSpec::new("file.saveAs", "Save As", "File", save_as).key("F12").params(r#"{"path": string, "password"?: string}"#).pure(),
+        CommandSpec::new("file.saveAs", "Save As", "File", save_as).key("F12").params(r#"{"path": string, "password"?: string, "markup"?: bool (as file.save)}"#).pure(),
         // Pure: the password must not land in Repeat or a recorded macro, and it isn't an edit
         // to undo; it marks the document as changed itself.
         CommandSpec::new("file.encrypt", "Encrypt with Password", "File › Info › Protect Document", encrypt)
@@ -46,13 +46,26 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("file.exportPdf", "Export PDF", "File › Export", |s, v| {
             let path = p::req_str(v, "path")?;
             let path = if path.to_ascii_lowercase().ends_with(".pdf") { path.to_string() } else { format!("{path}.pdf") };
-            crate::io::save_path(std::path::Path::new(&path), &s.doc).map_err(CmdError::Failed)?;
-            Ok(json!({"path": path}))
+            let opts = export_options(s, v);
+            crate::io::save_path_with(std::path::Path::new(&path), &s.doc, None, &opts).map_err(CmdError::Failed)?;
+            Ok(json!({"path": path, "markup": opts.markup}))
         })
-        .params(r#"{"path": string}"#)
+        .params(r#"{"path": string, "markup"?: bool (Print Markup: tracked changes marked up and each page scaled down beside the comments in balloons; default file.printMarkup)}"#)
         .pure(),
         CommandSpec::new("file.exportPng", "Export Page as PNG", "File › Export", export_png)
-            .params(r#"{"path": string, "page"?: n (1-based), "scale"?: px per pt}"#)
+            .params(r#"{"path": string, "page"?: n (1-based), "scale"?: px per pt, "markup"?: bool (the page with its comments in balloons beside it; default file.printMarkup)}"#)
+            .pure(),
+        // A print setting, like Word's: not part of the document, so no undo step.
+        CommandSpec::new("file.printMarkup", "Print Markup", "File › Print", |s, v| {
+            s.prefs.print_markup = p::bool(v, "value").unwrap_or(!s.prefs.print_markup);
+            Ok(json!({"value": s.prefs.print_markup}))
+        })
+        .params(r#"{"value"?: bool (omit to toggle)} — PDFs, prints and copies show comments (balloons beside each page; a list at the end of HTML, Markdown and text) and tracked changes"#)
+        .pure(),
+        CommandSpec::new("file.printPdf", "Print to PDF", "File › Print", crate::print::print_pdf_to_file)
+            .params(
+                r#"{"path": string, "range"?: "all" | "current" | "selection" (the pages the selection touches) | "custom", "pages"?: "1-3,5" (implies custom), "parity"?: "all" | "odd" | "even", "copies"?: 1-999, "collate"?: bool (default true)}"#,
+            )
             .pure(),
         CommandSpec::new("file.print", "Print", "File", |s, _| {
             s.ui_requests.push(json!({"open": "print"}));
@@ -69,11 +82,6 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("file.properties", "Properties", "File › Info", properties)
             .params(r#"{"title"?, "subject"?, "author"?, "keywords"?, "comments"?, "category"?, "custom"?: {name: string | null (removes)}}"#),
         CommandSpec::new("file.info", "Info", "File", info).pure(),
-        CommandSpec::new("file.options", "Options", "File", |s, _| {
-            s.ui_requests.push(json!({"open": "options"}));
-            sel_result(s)
-        })
-        .pure(),
         CommandSpec::new("file.setAuthor", "User Name", "File › Options › General", set_author)
             .params(r#"{"name": string (author of new tracked changes and comments)}"#)
             .pure(),
@@ -192,10 +200,10 @@ fn save(s: &mut Session, v: &Value) -> CmdResult {
     }
     s.stamp_save();
     let password = s.password.as_ref().map(crate::io::Password::as_str);
-    crate::io::save_path_with(&path, &s.doc, password).map_err(CmdError::Failed)?;
+    crate::io::save_path_with(&path, &s.doc, password, &export_options(s, v)).map_err(CmdError::Failed)?;
     let encrypted = password.is_some() && crate::io::can_encrypt(&path.to_string_lossy());
     let ext = path.extension().and_then(|e| e.to_str()).unwrap_or("").to_ascii_lowercase();
-    if ["docx", "docm", "dotx", "dotm", "odt", "rtf", "json"].contains(&ext.as_str()) {
+    if ["docx", "docm", "dotx", "dotm", "odt", "rtf", "json", "xml"].contains(&ext.as_str()) {
         s.path = Some(path.clone());
         s.dirty = false;
     }
@@ -210,11 +218,18 @@ fn save_as(s: &mut Session, v: &Value) -> CmdResult {
     save(s, v)
 }
 
+/// How a copy is written: Print Markup from the command's `markup`, else the File › Print
+/// setting (`file.printMarkup`); comments as Track Changes Options show them.
+pub fn export_options(s: &Session, v: &Value) -> crate::io::ExportOptions {
+    let markup = p::bool(v, "markup").unwrap_or(s.prefs.print_markup);
+    crate::io::ExportOptions { markup, comments: markup && s.prefs.markup.comments }
+}
+
 fn export_png(s: &mut Session, v: &Value) -> CmdResult {
     let path = p::req_str(v, "path")?;
     let page = p::u64(v, "page").unwrap_or(1).max(1) as usize - 1;
     let scale = p::f32(v, "scale").unwrap_or(2.0).clamp(0.1, 8.0);
-    let l = s.export_layout();
+    let l = s.export_layout_with(export_options(s, v).markup);
     let pg = l.pages.get(page).ok_or_else(|| CmdError::Params(format!("no page {}", page + 1)))?;
     let img = wordcraft_render::render_page(&s.doc, pg, scale, &Default::default());
     let png = img.to_png();
diff --git a/crates/engine/src/cmd/find_pattern.rs b/crates/engine/src/cmd/find_pattern.rs
new file mode 100644
index 0000000000..2c39bca3ae
--- /dev/null
+++ b/crates/engine/src/cmd/find_pattern.rs
@@ -0,0 +1,417 @@
+//! Word's Find and Replace patterns (#543): special characters (`^p`, `^t`, `^#` …) and the
+//! "Use wildcards" language (`?`, `*`, `[a-z]`, `{n,m}`, `@`, `<`, `>`, `( )`), translated to a
+//! regular expression for the linear-time `regex` engine, so no pattern can backtrack
+//! catastrophically. Replace text understands the same codes plus `^&` (the found text), `^c`
+//! (the clipboard) and, with wildcards, `\1`–`\9` (the groups).
+//!
+//! The search reads a story as text with a paragraph mark (`\r`, [`PARA_MARK`]) between
+//! paragraphs when the pattern can match one, so `^p` finds paragraph ends; a paragraph that ends
+//! a section ends with [`SECT_MARK`] instead (`^b`).
+
+use regex::escape;
+
+/// A paragraph mark in the searched text.
+pub const PARA_MARK: char = '\r';
+/// The mark of a paragraph that ends a section (`^b`), in the searched text only.
+pub const SECT_MARK: char = '\u{1D}';
+/// Longest Find what text, in characters.
+pub const MAX_PATTERN: usize = 1024;
+/// Largest count in `{n,m}`.
+const MAX_COUNT: u32 = 1000;
+/// Any character except a paragraph mark (`?`, `^?`, `*`).
+const ANY: &str = r"[^\r\x{1D}]";
+
+/// How the Find what text is read.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct Opts {
+    pub match_case: bool,
+    pub whole_word: bool,
+    pub prefix: bool,
+    pub suffix: bool,
+    pub ignore_punct: bool,
+    pub ignore_space: bool,
+    /// Word's "Use wildcards".
+    pub wildcards: bool,
+    /// A regular expression (WordCraft's own option; wins over wildcards).
+    pub regex: bool,
+    /// Take the text literally: no `^` codes.
+    pub literal: bool,
+}
+
+/// A pattern ready for the regex engine.
+#[derive(Debug)]
+pub struct Compiled {
+    pub pattern: String,
+    pub case_insensitive: bool,
+    /// The pattern can match a paragraph mark, so the search must read across paragraphs.
+    pub spans_paras: bool,
+}
+
+/// What a `^` code stands for in Find what.
+fn find_code(c: char) -> Option<&'static str> {
+    Some(match c {
+        'p' => r"\r",
+        'b' => r"\x{1D}",
+        't' => r"\t",
+        '?' => ANY,
+        '#' => "[0-9]",
+        '$' => r"\p{L}",
+        '^' => r"\^",
+        'l' => r"\n",
+        'm' => r"\x{0C}",
+        'n' => r"\x{0E}",
+        '+' => r"\x{2014}",
+        '=' => r"\x{2013}",
+        's' => r"\x{A0}",
+        '~' => r"\x{2011}",
+        '-' => r"\x{AD}",
+        'w' => r"[ \t\x{A0}]+",
+        'g' => r"\x{FFFC}",
+        '%' => "§",
+        'v' => "¶",
+        _ => return None,
+    })
+}
+
+/// What a `^` code stands for in Replace with.
+fn replace_code(c: char) -> Option<char> {
+    Some(match c {
+        'p' => PARA_MARK,
+        't' => '\t',
+        '^' => '^',
+        'l' => '\n',
+        'm' => '\u{0C}',
+        'n' => '\u{0E}',
+        '+' => '\u{2014}',
+        '=' => '\u{2013}',
+        's' => '\u{A0}',
+        '~' => '\u{2011}',
+        '-' => '\u{AD}',
+        '%' => '§',
+        'v' => '¶',
+        _ => return None,
+    })
+}
+
+/// A character code (`^13`, `^0151`, `^u8212`) as the character it stands for here.
+fn code_char(n: u32) -> Option<char> {
+    Some(match n {
+        13 => PARA_MARK,
+        11 => '\n',
+        12 => '\u{0C}',
+        14 => '\u{0E}',
+        30 => '\u{2011}',
+        31 => '\u{AD}',
+        n => char::from_u32(n).filter(|c| !c.is_control() || *c == '\t')?,
+    })
+}
+
+/// Read a numeric code after `^` (`13`, `0151`, `u8212`) starting at `chars[i]`; returns the
+/// character and how many characters it took.
+fn numeric_code(chars: &[char], i: usize) -> Option<(char, usize)> {
+    let (start, max) = if chars.get(i) == Some(&'u') { (i + 1, 5) } else { (i, 4) };
+    let digits: String = chars.get(start..).unwrap_or(&[]).iter().take(max).take_while(|c| c.is_ascii_digit()).collect();
+    if digits.is_empty() {
+        return None;
+    }
+    let n: u32 = digits.parse().ok()?;
+    Some((code_char(n)?, start - i + digits.chars().count()))
+}
+
+/// A literal character as a regex atom.
+fn lit(c: char) -> String {
+    if c == PARA_MARK {
+        return r"\r".into();
+    }
+    escape(c.encode_utf8(&mut [0; 4]))
+}
+
+/// Translate Word's Find what text.
+pub fn compile(query: &str, o: &Opts) -> Result<Compiled, String> {
+    if query.chars().count() > MAX_PATTERN {
+        return Err(format!("the Find what text is longer than {MAX_PATTERN} characters"));
+    }
+    let (pat, spans) = if o.regex {
+        (query.to_string(), false)
+    } else if o.literal {
+        (escape(query), false)
+    } else if o.wildcards {
+        wildcards(query)?
+    } else {
+        special(query, o)
+    };
+    let wrap = |p: String| format!("(?:{p})");
+    let pat = if o.wildcards && !o.regex {
+        pat
+    } else if o.whole_word {
+        format!(r"\b{}\b", wrap(pat))
+    } else {
+        match (o.prefix, o.suffix) {
+            (true, true) => format!(r"\b{}\b", wrap(pat)),
+            (true, false) => format!(r"\b{}", wrap(pat)),
+            (false, true) => format!(r"{}\b", wrap(pat)),
+            (false, false) => pat,
+        }
+    };
+    // Word's wildcard search always matches case.
+    let case_insensitive = !o.match_case && !(o.wildcards && !o.regex);
+    Ok(Compiled { pattern: pat, case_insensitive, spans_paras: spans })
+}
+
+/// Normal search: literal text with `^` codes, optionally skipping punctuation and white space.
+fn special(query: &str, o: &Opts) -> (String, bool) {
+    let chars: Vec<char> = query.chars().collect();
+    let mut atoms: Vec<String> = Vec::new();
+    let mut spans = false;
+    let mut i = 0;
+    while let Some(&c) = chars.get(i) {
+        i += 1;
+        if c == '^'
+            && let Some(&n) = chars.get(i)
+        {
+            if let Some(code) = find_code(n) {
+                spans |= matches!(n, 'p' | 'b');
+                atoms.push(code.to_string());
+                i += 1;
+                continue;
+            }
+            if let Some((ch, used)) = numeric_code(&chars, i) {
+                spans |= ch == PARA_MARK;
+                atoms.push(lit(ch));
+                i += used;
+                continue;
+            }
+            // Not a code: the caret itself.
+        }
+        if (o.ignore_punct && is_punct(c)) || (o.ignore_space && is_space(c)) {
+            continue;
+        }
+        atoms.push(lit(c));
+    }
+    let filler = match (o.ignore_punct, o.ignore_space) {
+        (true, true) => r"[\p{P} \t\x{A0}]*",
+        (true, false) => r"\p{P}*",
+        (false, true) => r"[ \t\x{A0}]*",
+        (false, false) => "",
+    };
+    (atoms.join(filler), spans)
+}
+
+fn is_punct(c: char) -> bool {
+    c.is_ascii_punctuation() || matches!(c, '\u{2010}'..='\u{2027}' | '\u{00A1}' | '\u{00BF}' | '\u{00AB}' | '\u{00BB}')
+}
+
+fn is_space(c: char) -> bool {
+    matches!(c, ' ' | '\t' | '\u{A0}')
+}
+
+/// "Use wildcards" search.
+fn wildcards(query: &str) -> Result<(String, bool), String> {
+    let chars: Vec<char> = query.chars().collect();
+    let mut out = String::new();
+    let mut spans = false;
+    let mut i = 0;
+    while let Some(&c) = chars.get(i) {
+        i += 1;
+        match c {
+            '?' => out.push_str(ANY),
+            '*' => {
+                out.push_str(ANY);
+                out.push_str("*?");
+            }
+            '@' => out.push('+'),
+            '<' => out.push_str(r"\b{start}"),
+            '>' => out.push_str(r"\b{end}"),
+            '(' | ')' => out.push(c),
+            '{' => {
+                let end = chars.get(i..).and_then(|r| r.iter().position(|c| *c == '}')).ok_or("a { needs a closing }")?;
+                let body: String = chars.get(i..i + end).unwrap_or(&[]).iter().collect();
+                out.push_str(&count(&body)?);
+                i += end + 1;
+            }
+            '[' => {
+                let end = chars.get(i..).and_then(|r| r.iter().position(|c| *c == ']')).ok_or("a [ needs a closing ]")?;
+                out.push_str(&class(chars.get(i..i + end).unwrap_or(&[]))?);
+                i += end + 1;
+            }
+            '\\' => match chars.get(i) {
+                Some(d) if d.is_ascii_digit() => return Err("back-references (\\1) work in Replace with, not in Find what".into()),
+                Some(&n) => {
+                    out.push_str(&lit(n));
+                    i += 1;
+                }
+                None => out.push_str(r"\\"),
+            },
+            '^' => {
+                let Some(&n) = chars.get(i) else {
+                    out.push_str(r"\^");
+                    continue;
+                };
+                if let Some(code) = find_code(n) {
+                    spans |= matches!(n, 'p' | 'b');
+                    out.push_str(code);
+                    i += 1;
+                } else if let Some((ch, used)) = numeric_code(&chars, i) {
+                    spans |= ch == PARA_MARK;
+                    out.push_str(&lit(ch));
+                    i += used;
+                } else {
+                    out.push_str(r"\^");
+                }
+            }
+            c => out.push_str(&lit(c)),
+        }
+    }
+    Ok((out, spans))
+}
+
+/// `{n}`, `{n,}`, `{n,m}` (and `{,m}`).
+fn count(body: &str) -> Result<String, String> {
+    let bad = || format!("{{{body}}} is not a valid count");
+    let num = |s: &str| -> Result<Option<u32>, String> {
+        let s = s.trim();
+        if s.is_empty() {
+            return Ok(None);
+        }
+        let n: u32 = s.parse().map_err(|_| bad())?;
+        if n > MAX_COUNT {
+            return Err(format!("counts go up to {MAX_COUNT}"));
+        }
+        Ok(Some(n))
+    };
+    match body.split_once([',', ';']) {
+        None => Ok(format!("{{{}}}", num(body)?.ok_or_else(bad)?)),
+        Some((a, b)) => {
+            let a = num(a)?.unwrap_or(0);
+            match num(b)? {
+                Some(b) if b < a => Err(bad()),
+                Some(b) => Ok(format!("{{{a},{b}}}")),
+                None => Ok(format!("{{{a},}}")),
+            }
+        }
+    }
+}
+
+/// `[abc]`, `[a-z]`, `[!x]`: the characters inside are literal.
+fn class(inner: &[char]) -> Result<String, String> {
+    let (neg, inner) = match inner.split_first() {
+        Some(('!', rest)) => (true, rest),
+        _ => (false, inner),
+    };
+    if inner.is_empty() {
+        return Err("[ ] needs at least one character".into());
+    }
+    let mut out = String::from(if neg { r"[^\r\x{1D}" } else { "[" });
+    let mut i = 0;
+    while let Some(&c) = inner.get(i) {
+        let c = if c == '\\' && i + 1 < inner.len() {
+            i += 1;
+            inner.get(i).copied().unwrap_or(c)
+        } else {
+            c
+        };
+        i += 1;
+        if inner.get(i) == Some(&'-')
+            && let Some(&hi) = inner.get(i + 1)
+        {
+            if hi < c {
+                return Err(format!("[{c}-{hi}] is not in ascending order"));
+            }
+            out.push_str(&format!("{}-{}", lit(c), lit(hi)));
+            i += 2;
+        } else {
+            out.push_str(&lit(c));
+        }
+    }
+    out.push(']');
+    Ok(out)
+}
+
+/// A piece of Replace with text.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Piece {
+    Lit(String),
+    /// `^&`: the text found.
+    Found,
+    /// `\n` with wildcards: group `n`.
+    Group(usize),
+    /// `^c`: the clipboard.
+    Clip,
+}
+
+/// Read Replace with text: `^` codes (unless `literal`), and `\1`–`\9` with wildcards.
+pub fn parse_replace(with: &str, o: &Opts) -> Vec<Piece> {
+    if o.literal || o.regex {
+        return vec![Piece::Lit(with.to_string())];
+    }
+    let chars: Vec<char> = with.chars().collect();
+    let mut out = Vec::new();
+    let mut cur = String::new();
+    let flush = |cur: &mut String, out: &mut Vec<Piece>| {
+        if !cur.is_empty() {
+            out.push(Piece::Lit(std::mem::take(cur)));
+        }
+    };
+    let mut i = 0;
+    while let Some(&c) = chars.get(i) {
+        i += 1;
+        if c == '\\' && o.wildcards {
+            match chars.get(i) {
+                Some(d) if d.is_ascii_digit() && *d != '0' => {
+                    flush(&mut cur, &mut out);
+                    out.push(Piece::Group(d.to_digit(10).unwrap_or(0) as usize));
+                    i += 1;
+                    continue;
+                }
+                Some(&n) => {
+                    cur.push(n);
+                    i += 1;
+                    continue;
+                }
+                None => {}
+            }
+        }
+        if c == '^'
+            && let Some(&n) = chars.get(i)
+        {
+            if n == '&' || n == 'c' {
+                flush(&mut cur, &mut out);
+                out.push(if n == '&' { Piece::Found } else { Piece::Clip });
+                i += 1;
+                continue;
+            }
+            if let Some(ch) = replace_code(n) {
+                cur.push(ch);
+                i += 1;
+                continue;
+            }
+            if let Some((ch, used)) = numeric_code(&chars, i) {
+                cur.push(ch);
+                i += used;
+                continue;
+            }
+        }
+        cur.push(c);
+    }
+    flush(&mut cur, &mut out);
+    out
+}
+
+/// Searched text as it is inserted again: marks become paragraph breaks.
+fn as_inserted(s: &str) -> String {
+    s.replace(SECT_MARK, "\r")
+}
+
+/// Fill in Replace with text for one match: `found` is the matched text, `group(n)` a group's.
+pub fn expand(pieces: &[Piece], found: &str, group: &dyn Fn(usize) -> Option<String>, clip: &str) -> String {
+    let mut out = String::new();
+    for p in pieces {
+        match p {
+            Piece::Lit(t) => out.push_str(t),
+            Piece::Found => out.push_str(&as_inserted(found)),
+            Piece::Group(n) => out.push_str(&as_inserted(&group(*n).unwrap_or_default())),
+            Piece::Clip => out.push_str(&clip.replace("\r\n", "\r").replace('\n', "\r")),
+        }
+    }
+    out
+}
diff --git a/crates/engine/src/cmd/fmt_revisions.rs b/crates/engine/src/cmd/fmt_revisions.rs
index 234bb52852..16b1a3e688 100644
--- a/crates/engine/src/cmd/fmt_revisions.rs
+++ b/crates/engine/src/cmd/fmt_revisions.rs
@@ -182,6 +182,13 @@ pub(crate) fn record(s: &mut Session, id: &str, before: &Document) {
     }
 }
 
+/// Compare Documents: record how paragraph `new` (the revised version, same text) is formatted
+/// differently from `old` as tracked formatting changes by `author`.
+pub(crate) fn compare_formatting(old: &Paragraph, new: &mut Paragraph, revisions: &mut Vec<Revision>, author: &str, date: &str) {
+    let mut r = Recorder { author: author.to_string(), date: date.to_string(), before: &[], revisions, rid: None };
+    r.para(old, new);
+}
+
 /// The properties a change sets, as the Style Inspector lists them: `[{"prop", "value"}]` in
 /// field order; a switch turned off is `false`, a value removed is `null`.
 pub fn diff<T: Serialize>(old: &T, new: &T) -> Vec<Value> {
diff --git a/crates/engine/src/cmd/font.rs b/crates/engine/src/cmd/font.rs
new file mode 100644
index 0000000000..703a868587
--- /dev/null
+++ b/crates/engine/src/cmd/font.rs
@@ -0,0 +1,107 @@
+//! Fonts the user adds without rebuilding (#582): `font.add`, `font.list`, `font.remove`.
+//!
+//! An added font joins the process-wide font database on top of the bundled and system fonts
+//! (never replacing a face already there), so it shows in the font lists, lays out, renders and
+//! embeds in PDFs like any other. Where it is kept between runs is [`FontDb::load_user_fonts`]'s
+//! folder (desktop); without one it lasts for the session (the web shell stores it itself).
+
+use serde_json::{Value, json};
+use wordcraft_fonts::{FontDb, UserFont};
+
+use crate::cmd::insert::base64_decode;
+use crate::{CmdError, CmdResult, CommandSpec, Session, p};
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec::new("font.add", "Add Font…", "Home › Font", add)
+            .params(r#"{"path"?: string, "data"?: base64, "name"?: string (file name for "data")} — a TTF, OTF, TTC, WOFF or WOFF2 file; none: pick a file"#)
+            .pure(),
+        CommandSpec::new("font.list", "Added Fonts", "Home › Font", list).params(r#"{"all"?: bool (also every available family)}"#).pure(),
+        CommandSpec::new("font.remove", "Remove Added Font", "Home › Font", remove).params(r#"{"family": string}"#).pure(),
+    ]
+}
+
+fn font_json(f: &UserFont) -> Value {
+    json!({
+        "file": f.file,
+        "families": f.families(),
+        "faces": f.faces.iter().map(|(family, style)| json!({"family": family, "style": style})).collect::<Vec<_>>(),
+        "path": f.path.as_ref().map(|p| p.to_string_lossy().to_string()),
+    })
+}
+
+/// Read a font file named by the user, refusing one larger than the cap before reading it.
+#[cfg(not(target_arch = "wasm32"))]
+fn read_font_file(path: &str) -> Result<Vec<u8>, CmdError> {
+    let meta = std::fs::metadata(path).map_err(|e| CmdError::Failed(format!("{path}: {e}")))?;
+    if !meta.is_file() {
+        return Err(CmdError::Failed(format!("{path}: not a file")));
+    }
+    if meta.len() > wordcraft_fonts::MAX_FONT_FILE_BYTES as u64 {
+        return Err(CmdError::Failed(format!("{path}: the font file is larger than {} MB", wordcraft_fonts::MAX_FONT_FILE_BYTES >> 20)));
+    }
+    std::fs::read(path).map_err(|e| CmdError::Failed(format!("{path}: {e}")))
+}
+
+fn add(s: &mut Session, v: &Value) -> CmdResult {
+    if p::str(v, "url").is_some() {
+        return Err(CmdError::Failed(
+            "adding a font from a link isn't available yet: download the font file and add it with {\"path\"} or {\"data\"}".into(),
+        ));
+    }
+    let (name, bytes) = if let Some(d) = p::str(v, "data") {
+        // Base64 is a third larger than the file: refuse before decoding an oversized one.
+        if d.len() / 4 * 3 > wordcraft_fonts::MAX_FONT_FILE_BYTES + 3 {
+            return Err(CmdError::Failed(format!("the font file is larger than {} MB", wordcraft_fonts::MAX_FONT_FILE_BYTES >> 20)));
+        }
+        let bytes = base64_decode(d).ok_or_else(|| CmdError::Params("bad base64 data".into()))?;
+        (p::str(v, "name").unwrap_or("font").to_string(), bytes)
+    } else if let Some(path) = p::str(v, "path") {
+        #[cfg(not(target_arch = "wasm32"))]
+        {
+            (path.to_string(), read_font_file(path)?)
+        }
+        #[cfg(target_arch = "wasm32")]
+        {
+            let _ = path;
+            return Err(CmdError::Failed("reading files by path isn't available on the web".into()));
+        }
+    } else {
+        // From the ribbon: the UI shows a file picker and runs this again with the file.
+        s.ui_requests.push(json!({"open": "addFont"}));
+        return Ok(json!({"pending": true}));
+    };
+    let r = FontDb::global().install_font(&name, &bytes).map_err(|e| CmdError::Failed(e.to_string()))?;
+    // Text already set in the family (shown in a fallback until now) takes the new font.
+    s.relayout();
+    let families = r.font.families().join(", ");
+    s.status = match &r.warning {
+        Some(w) => format!("Added {families} ({w})"),
+        None => format!("Added {families}"),
+    };
+    let mut out = font_json(&r.font);
+    if let Some(w) = r.warning {
+        out["warning"] = json!(w);
+    }
+    Ok(out)
+}
+
+fn list(_: &mut Session, v: &Value) -> CmdResult {
+    let db = FontDb::global();
+    let mut out = json!({
+        "fonts": db.user_fonts().iter().map(font_json).collect::<Vec<_>>(),
+        "folder": db.user_font_dir().map(|p| p.to_string_lossy().to_string()),
+    });
+    if p::bool(v, "all") == Some(true) {
+        out["families"] = json!(db.families());
+    }
+    Ok(out)
+}
+
+fn remove(s: &mut Session, v: &Value) -> CmdResult {
+    let family = p::str(v, "family").filter(|f| !f.trim().is_empty()).ok_or_else(|| CmdError::Params("family is required".into()))?;
+    let gone = FontDb::global().remove_user_font(family.trim()).map_err(|e| CmdError::Failed(e.to_string()))?;
+    s.relayout();
+    s.status = format!("Removed {}", family.trim());
+    Ok(json!({"removed": gone.iter().map(font_json).collect::<Vec<_>>()}))
+}
diff --git a/crates/engine/src/cmd/format.rs b/crates/engine/src/cmd/format.rs
index 633c0b3778..069310090d 100644
--- a/crates/engine/src/cmd/format.rs
+++ b/crates/engine/src/cmd/format.rs
@@ -95,7 +95,7 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("format.shadow", "Shadow", "Home › Font › Text Effects", |s, v| toggle(s, v, |r| r.shadow, |c, on| c.shadow = Some(on))),
         CommandSpec::new("format.emboss", "Emboss", "Home › Font › Font", |s, v| toggle(s, v, |r| r.emboss, |c, on| c.emboss = Some(on))),
         CommandSpec::new("format.engrave", "Engrave", "Home › Font › Font", |s, v| toggle(s, v, |r| r.engrave, |c, on| c.engrave = Some(on))),
-        CommandSpec::new("format.font", "Font", "Home › Font", font).key("Mod+Shift+F").params(r#"{"name": string}"#),
+        CommandSpec::new("format.font", "Font", "Home › Font", font).key("Mod+Shift+F").params(r#"{"name"?: string, "eastAsia"?: string}"#),
         CommandSpec::new("format.size", "Font Size", "Home › Font", size).key("Mod+Shift+P").params(r#"{"size": number}"#),
         CommandSpec::new("format.growFont", "Increase Font Size", "Home › Font", |s, _| step_size(s, 1)).key("Mod+Shift+. / Mod+Shift+>"),
         CommandSpec::new("format.shrinkFont", "Decrease Font Size", "Home › Font", |s, _| step_size(s, -1)).key("Mod+Shift+, / Mod+Shift+<"),
@@ -275,15 +275,38 @@ fn underline(s: &mut Session, v: &Value) -> CmdResult {
     apply(s, &|c| c.underline = Some(u))
 }
 
+/// `format.font`: `name` is the font (Latin text, and Persian/Arabic text too); `eastAsia` sets the
+/// East Asian text's font on its own, as the Font dialog's Asian text font box does (#505).
 fn font(s: &mut Session, v: &Value) -> CmdResult {
-    let name = p::req_str(v, "name")?.trim().to_string();
-    if name.is_empty() || name.len() > 128 {
-        return Err(CmdError::Params("bad font name".into()));
+    let arg = |k: &str| -> Result<Option<String>, CmdError> {
+        let Some(n) = v.get(k) else { return Ok(None) };
+        let n = n.as_str().map(str::trim).unwrap_or("");
+        if n.is_empty() || n.len() > 128 {
+            return Err(CmdError::Params(format!("bad font name `{k}`")));
+        }
+        Ok(Some(n.to_string()))
+    };
+    let (name, east_asia) = (arg("name")?, arg("eastAsia")?);
+    if name.is_none() && east_asia.is_none() {
+        return Err(CmdError::Params("`name` or `eastAsia` (string) is required".into()));
     }
-    // The font applies to Persian/Arabic text in the selection too (its complex-script font).
+    // The font applies to Persian/Arabic text in the selection too (its complex-script font). A
+    // Chinese, Japanese or Korean font is the East Asian text's font as well (`w:eastAsia`), as in
+    // Word; choosing a Latin font leaves that text's font as it was.
+    let ea = east_asia.or_else(|| {
+        name.clone().filter(|n| {
+            let r = wordcraft_fonts::word::resolve(n, false, false);
+            !r.substituted && r.face.is_east_asian()
+        })
+    });
     apply(s, &|c| {
-        c.font = Some(name.clone());
-        c.font_cs = Some(name.clone());
+        if let Some(n) = &name {
+            c.font = Some(n.clone());
+            c.font_cs = Some(n.clone());
+        }
+        if let Some(n) = &ea {
+            c.font_ea = Some(n.clone());
+        }
     })
 }
 
@@ -371,75 +394,142 @@ fn change_case(s: &mut Session, v: &Value) -> CmdResult {
         }
     });
     for path in s.doc.paths_between(&a, &b) {
-        let (from, to, src) = {
+        // Changed stretches of one run each: (start, end, replacement), in text order.
+        let groups = {
             let Some(p) = s.doc.para(a.story, &path) else { continue };
             let from = if path == a.path { a.off } else { 0 };
             let to = if path == b.path { b.off } else { p.len() };
-            (from, to, p.text.get(from..to).unwrap_or("").to_string())
+            let Some(src) = p.text.get(from..to) else { continue };
+            case_groups(p, from, src, &convert_chars(src, &mode, from == 0))
         };
-        let new = convert(&src, &mode, from == 0);
-        if new.len() != src.len() {
-            // Lengths differ (ß → SS): replace text keeping the first run's formatting.
-            let para = s.doc.para_mut(a.story, &path)?;
-            let props = para.props_of_char(from).clone();
-            para.delete(from, to)?;
-            para.insert_text(from, &new, &props)?;
-        } else {
-            let para = s.doc.para_mut(a.story, &path)?;
-            if let Some(slice) = para.text.get(from..to)
-                && slice.len() == new.len()
-            {
-                para.text.replace_range(from..to, &new);
-                para.touch();
+        if groups.is_empty() {
+            continue;
+        }
+        // Each stretch keeps its own run's formatting (#421); right to left so offsets hold.
+        let para = s.doc.para_mut(a.story, &path)?;
+        for (start, end, new) in groups.iter().rev() {
+            if new.len() == end - start {
+                if para.text.get(*start..*end).is_some() {
+                    para.text.replace_range(*start..*end, new);
+                }
+            } else {
+                let props = para.props_of_char(*start).clone();
+                para.delete(*start, *end)?;
+                para.insert_text(*start, new, &props)?;
+            }
+        }
+        para.touch();
+        // The selection keeps covering the converted text when its length changed (#420).
+        let spans: Vec<(usize, usize, usize)> = groups.iter().map(|(x, y, n)| (*x, *y, n.len())).collect();
+        for end in [&mut s.sel.anchor, &mut s.sel.focus] {
+            if end.story == a.story && end.path == path {
+                end.off = map_offset(&spans, end.off);
             }
         }
     }
     sel_result(s)
 }
 
+/// Group the characters of `src` (at `from` in `p`) whose converted form `conv` differs into
+/// stretches that stay inside one run: `(start, end, replacement)`, in text order.
+fn case_groups(p: &wordcraft_doc::Paragraph, from: usize, src: &str, conv: &[String]) -> Vec<(usize, usize, String)> {
+    let runs: Vec<std::ops::Range<usize>> = p.run_ranges().map(|(r, _)| r).collect();
+    let run_of = |off: usize| runs.iter().position(|r| r.contains(&off));
+    let mut out: Vec<(usize, usize, String, Option<usize>)> = Vec::new();
+    for ((i, c), new) in src.char_indices().zip(conv) {
+        let (start, end) = (from + i, from + i + c.len_utf8());
+        let mut buf = [0u8; 4];
+        if new.as_str() == c.encode_utf8(&mut buf) {
+            continue;
+        }
+        let run = run_of(start);
+        match out.last_mut() {
+            Some(g) if g.1 == start && g.3 == run => {
+                g.1 = end;
+                g.2.push_str(new);
+            }
+            _ => out.push((start, end, new.clone(), run)),
+        }
+    }
+    out.into_iter().map(|(a, b, n, _)| (a, b, n)).collect()
+}
+
+/// Where `off` lands after the stretches `(start, end, new_len)` (text order) were replaced;
+/// an offset inside a stretch moves to its end.
+fn map_offset(spans: &[(usize, usize, usize)], off: usize) -> usize {
+    let mut out = off;
+    for &(start, end, new_len) in spans {
+        if end <= off {
+            out = out.saturating_sub(end.saturating_sub(start)).saturating_add(new_len);
+        } else if start < off {
+            out = out.saturating_sub(off - start).saturating_add(new_len);
+        }
+    }
+    out
+}
+
 fn is_title(t: &str) -> bool {
     t.split_whitespace().all(|w| w.chars().next().is_some_and(char::is_uppercase))
 }
 
+#[cfg(test)]
 fn convert(src: &str, mode: &str, para_start: bool) -> String {
-    match mode {
-        "upper" => src.to_uppercase(),
-        "lower" => src.to_lowercase(),
-        "toggle" => src.chars().map(|c| if c.is_uppercase() { c.to_lowercase().collect::<String>() } else { c.to_uppercase().collect() }).collect(),
-        "title" => {
-            let mut out = String::with_capacity(src.len());
-            let mut up = true;
-            for c in src.chars() {
-                if up && c.is_alphabetic() {
-                    out.extend(c.to_uppercase());
-                    up = false;
+    convert_chars(src, mode, para_start).concat()
+}
+
+/// The case-converted form of each character of `src`, in order (one entry per char, so a
+/// change of length such as ß → SS or İ → i̇ can be applied run by run).
+fn convert_chars(src: &str, mode: &str, para_start: bool) -> Vec<String> {
+    let chars: Vec<char> = src.chars().collect();
+    // Greek capital sigma lowers to the final form at the end of a word (as `str::to_lowercase`).
+    let lower = |i: usize, c: char| -> String {
+        let prev = i.checked_sub(1).and_then(|j| chars.get(j)).is_some_and(|p| p.is_alphabetic());
+        let next = chars.get(i + 1).is_some_and(|n| n.is_alphabetic());
+        if c == 'Σ' && prev && !next { "ς".to_string() } else { c.to_lowercase().collect() }
+    };
+    // Title case capitalises the first word of any selection; sentence case only at a paragraph start.
+    let mut up = mode == "title" || para_start;
+    let mut out = Vec::with_capacity(chars.len());
+    for (i, &c) in chars.iter().enumerate() {
+        let new = match mode {
+            "upper" => c.to_uppercase().collect(),
+            "lower" => lower(i, c),
+            "toggle" => {
+                if c.is_uppercase() {
+                    lower(i, c)
                 } else {
-                    out.extend(c.to_lowercase());
+                    c.to_uppercase().collect()
                 }
+            }
+            "title" => {
+                let n = if up && c.is_alphabetic() {
+                    up = false;
+                    c.to_uppercase().collect()
+                } else {
+                    lower(i, c)
+                };
                 if c.is_whitespace() {
                     up = true;
                 }
+                n
             }
-            out
-        }
-        _ => {
-            // Sentence case.
-            let mut out = String::with_capacity(src.len());
-            let mut up = para_start;
-            for c in src.chars() {
-                if up && c.is_alphabetic() {
-                    out.extend(c.to_uppercase());
+            _ => {
+                // Sentence case.
+                let n = if up && c.is_alphabetic() {
                     up = false;
+                    c.to_uppercase().collect()
                 } else {
-                    out.extend(c.to_lowercase());
-                }
+                    lower(i, c)
+                };
                 if matches!(c, '.' | '!' | '?') {
                     up = true;
                 }
+                n
             }
-            out
-        }
+        };
+        out.push(new);
     }
+    out
 }
 
 fn clear(s: &mut Session, _: &Value) -> CmdResult {
@@ -495,6 +585,7 @@ pub fn state(s: &Session) -> Value {
     let style_name = s.doc.styles.get(&style).map(|st| st.name.clone()).unwrap_or(style.clone());
     json!({
         "font": same(&|r| json!(r.font)),
+        "fontEastAsia": same(&|r| json!(r.font_ea)),
         "size": same(&|r| json!(r.size)),
         "bold": all.iter().all(|r| r.bold),
         "italic": all.iter().all(|r| r.italic),
@@ -503,6 +594,10 @@ pub fn state(s: &Session) -> Value {
         "border": all.iter().all(|r| r.border.is_some()),
         "subscript": all.iter().all(|r| r.vert_align == VertAlign::Subscript),
         "superscript": all.iter().all(|r| r.vert_align == VertAlign::Superscript),
+        "smallCaps": all.iter().all(|r| r.small_caps),
+        "caps": all.iter().all(|r| r.caps),
+        "hidden": all.iter().all(|r| r.hidden),
+        "spacing": same(&|r| json!(r.spacing)),
         "color": same(&|r| json!(match r.color { TextColor::Auto => "auto".to_string(), TextColor::Rgb(c) => c.hex() })),
         "highlight": same(&|r| json!(r.highlight.map(|c| c.hex()))),
         "style": style,
@@ -523,6 +618,8 @@ mod tests {
         assert_eq!(convert("hello WORLD", "title", true), "Hello World");
         assert_eq!(convert("Hello", "toggle", true), "hELLO");
         assert_eq!(convert("straße", "upper", true), "STRASSE");
+        assert_eq!(convert("hello world", "title", false), "Hello World");
+        assert_eq!(convert("ΣΟΦΟΣ ΟΔΟΣ", "lower", true), "σοφος οδος");
     }
 }
 
diff --git a/crates/engine/src/cmd/index.rs b/crates/engine/src/cmd/index.rs
new file mode 100644
index 0000000000..3b1cc4c25b
--- /dev/null
+++ b/crates/engine/src/cmd/index.rs
@@ -0,0 +1,440 @@
+//! References › Index: Mark Entry (XE fields), Insert Index and Update Index (the INDEX field).
+//! Field switches follow ECMA-376 §17.16.5.32 (INDEX) and §17.16.5.79 (XE).
+
+use std::collections::BTreeMap;
+
+use serde_json::{Value, json};
+use wordcraft_doc::para::InlineObject;
+use wordcraft_doc::props::{CharProps, TabAlign, TabLeader, TabStop};
+use wordcraft_doc::section::SectionStart;
+use wordcraft_doc::{Block, Paragraph, Path, Pos, StoryRef};
+
+use super::references::{FieldCode, leader};
+use super::sel_result;
+use crate::{CmdError, CmdResult, CommandSpec, Session, p};
+
+/// The paragraph style generated lists use for their entries (see `citations.rs`).
+const ENTRY_STYLE: &str = "ListEntry";
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec::new("references.markEntry", "Mark Entry", "References › Index", mark_entry).params(
+            r#"{"entry"?: string (the selection), "subentry"?: string, "crossReference"?: "See …", "bookmark"?: page-range bookmark, "bold"?: bool, "italic"?: bool, "all"?: bool (Mark All: every paragraph's first match of "text" or the selection)}"#,
+        )
+        .key(super::non_mac("Alt+Shift+X")),
+        CommandSpec::new("references.index", "Insert Index", "References › Index", insert_index).params(
+            r#"{"type"?: "indented|runIn", "columns"?: 1-4, "rightAlign"?: bool, "tabLeader"?: "dot|hyphen|underscore|none", "headings"?: bool (letter headings)} (replaces an existing index's settings)"#,
+        ),
+        CommandSpec::new("references.updateIndex", "Update Index", "References › Index", |s, _| {
+            super::citations::update_generated(s)?;
+            sel_result(s)
+        }),
+    ]
+}
+
+fn clean(t: &str, max: usize) -> String {
+    t.chars().filter(|c| *c != '"' && !c.is_control()).take(max).collect::<String>().trim().to_string()
+}
+
+/// The XE field for `references.markEntry`'s parameters: `XE "Main:Sub" \t "See X"` or
+/// `\r bookmark`, then `\b` and `\i` for a bold or italic page number.
+fn xe_instr(s: &Session, v: &Value, main: &str) -> Result<String, CmdError> {
+    let sub = p::str(v, "subentry").map(|t| clean(t, 200)).unwrap_or_default();
+    let mut instr = if sub.is_empty() { format!("XE \"{main}\"") } else { format!("XE \"{main}:{sub}\"") };
+    if let Some(see) = p::str(v, "crossReference").map(|t| clean(t, 200)).filter(|t| !t.is_empty()) {
+        instr.push_str(&format!(" \\t \"{see}\""));
+    } else if let Some(bm) = p::str(v, "bookmark").filter(|b| !b.trim().is_empty()) {
+        if !s.doc.bookmarks().iter().any(|(n, _)| n == bm) {
+            return Err(CmdError::Params(format!("no bookmark `{bm}`")));
+        }
+        instr.push_str(&format!(" \\r {}", bm.trim()));
+    }
+    if p::bool(v, "bold").unwrap_or(false) {
+        instr.push_str(" \\b");
+    }
+    if p::bool(v, "italic").unwrap_or(false) {
+        instr.push_str(" \\i");
+    }
+    Ok(instr)
+}
+
+fn mark_entry(s: &mut Session, v: &Value) -> CmdResult {
+    let main = clean(&p::str(v, "entry").map(str::to_string).unwrap_or_else(|| s.selected_text()), 200);
+    if main.is_empty() {
+        return Err(CmdError::Params("select a word or give `entry`".into()));
+    }
+    let instr = xe_instr(s, v, &main)?;
+    let hidden = CharProps { hidden: Some(true), ..Default::default() };
+    let field = || InlineObject::Field { instr: instr.clone(), result: String::new(), locked: false, code: false };
+    if !p::bool(v, "all").unwrap_or(false) {
+        let (_, b) = s.sel.ordered();
+        s.doc.insert_object(&b, field(), &hidden)?;
+        return Ok(json!({"entry": main, "marked": 1}));
+    }
+    // Mark All: the first whole-word, same-case match in every paragraph that hasn't this entry.
+    let text = p::str(v, "text").map(str::to_string).unwrap_or_else(|| {
+        let t = s.selected_text();
+        if t.trim().is_empty() { main.clone() } else { t.trim().to_string() }
+    });
+    if text.is_empty() {
+        return Err(CmdError::Params("nothing to look for".into()));
+    }
+    let mut marked = 0u32;
+    for path in s.doc.para_paths(StoryRef::Body) {
+        let Some(para) = s.doc.para(StoryRef::Body, &path) else { continue };
+        if para.props.style.as_deref().is_some_and(|st| st == ENTRY_STYLE || st.starts_with("TOC")) {
+            continue;
+        }
+        if para.objects.iter().any(|o| matches!(o, InlineObject::Field { instr: i, .. } if *i == instr)) {
+            continue;
+        }
+        let whole = |a: usize, b: usize| {
+            let before = para.text.get(..a).and_then(|t| t.chars().next_back()).is_none_or(|c| !c.is_alphanumeric());
+            let after = para.text.get(b..).and_then(|t| t.chars().next()).is_none_or(|c| !c.is_alphanumeric());
+            before && after
+        };
+        let Some(end) = para.text.match_indices(&text).map(|(a, m)| (a, a + m.len())).find(|(a, b)| whole(*a, *b)).map(|(_, b)| b) else {
+            continue;
+        };
+        s.doc.insert_object(&Pos { story: StoryRef::Body, path, off: end }, field(), &hidden)?;
+        marked += 1;
+    }
+    s.clamp_selection();
+    Ok(json!({"entry": main, "marked": marked}))
+}
+
+/// The INDEX field for `references.index`'s parameters: `\h "A"` letter headings, `\c "n"`
+/// columns, `\e` with a tab for right-aligned page numbers, `\r` run-in subentries.
+pub fn index_instr(v: &Value) -> String {
+    let mut s = String::from("INDEX");
+    if p::bool(v, "headings").unwrap_or(true) {
+        s.push_str(" \\h \"A\"");
+    }
+    let cols = p::u64(v, "columns").unwrap_or(1).clamp(1, 4);
+    if cols > 1 {
+        s.push_str(&format!(" \\c \"{cols}\""));
+    }
+    if p::bool(v, "rightAlign").unwrap_or(false) {
+        s.push_str(" \\e \"\t\"");
+    }
+    if p::str(v, "type") == Some("runIn") {
+        s.push_str(" \\r");
+    }
+    s
+}
+
+/// The body block holding the INDEX field, and its instruction.
+fn index_field(s: &Session) -> Option<(usize, String)> {
+    s.doc.body.iter().enumerate().find_map(|(i, b)| {
+        b.as_para()?.objects.iter().find_map(|o| match o {
+            InlineObject::Field { instr, .. } if FieldCode::parse(instr).name == "INDEX" => Some((i, instr.clone())),
+            _ => None,
+        })
+    })
+}
+
+fn insert_index(s: &mut Session, v: &Value) -> CmdResult {
+    let instr = index_instr(v);
+    match index_field(s) {
+        Some((i, _)) => {
+            // Settings for the index that is there: a new field code, then rebuild it.
+            let para = s.doc.para_mut(StoryRef::Body, &Path::top(i))?;
+            for o in para.objects.iter_mut() {
+                if let InlineObject::Field { instr: old, .. } = o
+                    && FieldCode::parse(old).name == "INDEX"
+                {
+                    *old = instr.clone();
+                }
+            }
+            para.touch();
+        }
+        None => super::citations::generated_list(s, &instr, "Index")?,
+    }
+    if let Some((i, _)) = index_field(s) {
+        rebuild(s, i, p::str(v, "tabLeader").map(leader))?;
+    }
+    s.clamp_selection();
+    sel_result(s)
+}
+
+/// One page reference of an entry.
+#[derive(Clone, Debug, PartialEq)]
+struct PageRef {
+    page: String,
+    bold: bool,
+    italic: bool,
+}
+
+#[derive(Default)]
+struct Node {
+    /// The entry's levels as written (the key is their lower-case form).
+    levels: Vec<String>,
+    pages: Vec<PageRef>,
+    see: Vec<String>,
+}
+
+/// Every XE entry in the body with its page (or page range), grouped by entry.
+fn collect(s: &mut Session) -> BTreeMap<Vec<String>, Node> {
+    let mut marks: Vec<(FieldCode, Pos)> = Vec::new();
+    for path in s.doc.para_paths(StoryRef::Body) {
+        let Some(p) = s.doc.para(StoryRef::Body, &path) else { continue };
+        for off in p.object_offsets() {
+            if let Some(InlineObject::Field { instr, .. }) = p.object_at(off) {
+                let f = FieldCode::parse(instr);
+                if f.name == "XE" {
+                    marks.push((f, Pos { story: StoryRef::Body, path: path.clone(), off }));
+                }
+            }
+        }
+    }
+    let l = s.layout();
+    let page = |pos: &Pos| l.caret(pos).and_then(|c| l.pages.get(c.page)).map(|p| p.number).unwrap_or(1);
+    let bookmark_end = |name: &str| {
+        s.doc.para_paths(StoryRef::Body).into_iter().find_map(|path| {
+            let p = s.doc.para(StoryRef::Body, &path)?;
+            let off = p.object_offsets().into_iter().find(|o| matches!(p.object_at(*o), Some(InlineObject::BookmarkEnd { name: n }) if n == name))?;
+            Some(Pos { story: StoryRef::Body, path, off })
+        })
+    };
+    let starts = s.doc.bookmarks();
+    let mut tree: BTreeMap<Vec<String>, Node> = BTreeMap::new();
+    for (f, pos) in marks {
+        let text = f.args.first().cloned().unwrap_or_default();
+        let levels: Vec<String> = text.split(':').map(|x| x.trim().to_string()).filter(|x| !x.is_empty()).take(9).collect();
+        if levels.is_empty() {
+            continue;
+        }
+        // Every level above gets a line of its own, even without pages.
+        for k in 1..levels.len() {
+            let head: Vec<String> = levels.iter().take(k).cloned().collect();
+            tree.entry(head.iter().map(|x| x.to_lowercase()).collect()).or_insert_with(|| Node { levels: head, ..Default::default() });
+        }
+        let node =
+            tree.entry(levels.iter().map(|x| x.to_lowercase()).collect()).or_insert_with(|| Node { levels: levels.clone(), ..Default::default() });
+        if let Some(see) = f.arg('t') {
+            if !node.see.iter().any(|x| x == see) {
+                node.see.push(see.to_string());
+            }
+            continue;
+        }
+        let range = f.arg('r').and_then(|bm| {
+            let a = starts.iter().find(|(n, _)| n == bm).map(|(_, p)| page(p))?;
+            let b = bookmark_end(bm).map(|p| page(&p)).unwrap_or(a);
+            Some(if b > a { format!("{a}\u{2013}{b}") } else { a.to_string() })
+        });
+        let r = PageRef { page: range.unwrap_or_else(|| page(&pos).to_string()), bold: f.has('b'), italic: f.has('i') };
+        match node.pages.iter_mut().find(|x| x.page == r.page) {
+            Some(x) => {
+                x.bold |= r.bold;
+                x.italic |= r.italic;
+            }
+            None => node.pages.push(r),
+        }
+    }
+    tree
+}
+
+/// Text runs of one index line.
+type Line = Vec<(String, CharProps)>;
+
+fn refs(line: &mut Line, node: &Node, sep: &str) {
+    for (k, r) in node.pages.iter().enumerate() {
+        line.push((if k == 0 { sep.to_string() } else { ", ".into() }, CharProps::default()));
+        line.push((r.page.clone(), CharProps { bold: r.bold.then_some(true), italic: r.italic.then_some(true), ..Default::default() }));
+    }
+    for (k, see) in node.see.iter().enumerate() {
+        let lead = if k > 0 || !node.pages.is_empty() { "; " } else { ". " };
+        line.push((lead.into(), CharProps::default()));
+        line.push((see.clone(), CharProps { italic: Some(true), ..Default::default() }));
+    }
+}
+
+/// Rebuild the index whose field is in body block `i`: entries sorted and grouped, indented or
+/// run-in (`\r`), letter headings (`\h`), the page separator (`\e`, a tab right-aligns the page
+/// numbers with `leader` or the leader the entries had), and `\c` columns as a continuous
+/// section of their own.
+pub fn rebuild(s: &mut Session, i: usize, leader: Option<TabLeader>) -> Result<(), CmdError> {
+    let Some(instr) = s.doc.body.get(i).and_then(|b| b.as_para()).and_then(|p| {
+        p.objects.iter().find_map(|o| match o {
+            InlineObject::Field { instr, .. } if FieldCode::parse(instr).name == "INDEX" => Some(instr.clone()),
+            _ => None,
+        })
+    }) else {
+        return Ok(());
+    };
+    let f = FieldCode::parse(&instr);
+    // Old entries go; keep their leader and the section their columns had.
+    let mut old_leader = None;
+    let mut old_sect = None;
+    while let Some(p) = s.doc.body.get(i + 1).and_then(|b| b.as_para()).filter(|p| p.props.style.as_deref() == Some(ENTRY_STYLE)) {
+        old_leader = old_leader.or_else(|| p.props.tabs.as_ref().and_then(|t| t.last()).map(|t| t.leader));
+        if p.section.is_some() {
+            old_sect = p.section.clone();
+        }
+        s.doc.remove_block(StoryRef::Body, &Path::top(i + 1))?;
+    }
+    let leader = leader.or(old_leader).unwrap_or(TabLeader::Dot);
+    let cols = f.arg('c').and_then(|c| c.trim().parse::<u32>().ok()).unwrap_or(1).clamp(1, 4);
+    let sep = f.arg('e').map(str::to_string).unwrap_or_else(|| ", ".into());
+    let run_in = f.has('r');
+    let headings = f.switches.iter().find(|(c, _)| *c == 'h').map(|(_, a)| a.clone().unwrap_or_default());
+    let tree = collect(s);
+    let mut lines: Vec<(usize, Line)> = Vec::new();
+    let mut letter: Option<String> = None;
+    let mut keys = tree.keys().peekable();
+    while let Some(key) = keys.next() {
+        let Some(node) = tree.get(key) else { continue };
+        let Some(main) = node.levels.first() else { continue };
+        if let Some(h) = &headings {
+            let first = main.chars().next().map(|c| c.to_uppercase().to_string());
+            if first != letter {
+                if letter.is_some() || !h.is_empty() {
+                    lines.push((0, vec![(if h.is_empty() { String::new() } else { first.clone().unwrap_or_default() }, CharProps::default())]));
+                }
+                letter = first;
+            }
+        }
+        if run_in {
+            // Subentries follow their main entry on its line: `Main, 3: sub, 4; other, 5`.
+            if node.levels.len() > 1 {
+                continue;
+            }
+            let mut line: Line = vec![(main.clone(), CharProps::default())];
+            refs(&mut line, node, &sep);
+            let mut first = true;
+            while let Some(sub) = keys.peek().filter(|k| k.len() > 1 && k.first() == key.first()).and_then(|k| tree.get(*k)) {
+                keys.next();
+                line.push((if first { ": " } else { "; " }.into(), CharProps::default()));
+                first = false;
+                line.push((sub.levels.iter().skip(1).cloned().collect::<Vec<_>>().join(", "), CharProps::default()));
+                refs(&mut line, sub, ", ");
+            }
+            lines.push((0, line));
+        } else {
+            let mut line: Line = vec![(node.levels.last().cloned().unwrap_or_default(), CharProps::default())];
+            refs(&mut line, node, &sep);
+            lines.push((node.levels.len().saturating_sub(1), line));
+        }
+    }
+    // Entries are laid out in the index's columns.
+    let sects = s.doc.sections();
+    let sect = sects.get(s.doc.section_index_of(i + 1)).map(|(_, x)| (*x).clone()).unwrap_or_default();
+    let space = old_sect.as_ref().map_or(sect.columns.space, |x| x.columns.space);
+    let col_w = (sect.text_width() - space * (cols as f32 - 1.0)) / cols as f32;
+    let n = lines.len();
+    for (k, (level, runs)) in lines.into_iter().enumerate() {
+        let mut para = Paragraph::new().styled(ENTRY_STYLE);
+        for (t, props) in runs {
+            let at = para.len();
+            para.insert_text(at, &t, &props)?;
+        }
+        para.props.indent_left = Some(18.0 * (level as f32 + 1.0));
+        para.props.indent_first = Some(-18.0);
+        if para.text.contains('\t') {
+            para.props.tabs = Some(vec![TabStop { pos: (col_w - 0.5).max(18.0), align: TabAlign::Right, leader }]);
+        }
+        s.doc.insert_block(StoryRef::Body, &Path::top(i + 1 + k), Block::Para(para))?;
+    }
+    columns(s, i, n, cols, old_sect.map(|b| *b))?;
+    s.touch();
+    Ok(())
+}
+
+/// Put the `n` entries after the index field's paragraph `i` in a continuous section with `cols`
+/// columns (the field's paragraph ends the section before), or merge that section back when the
+/// index has one column again.
+fn columns(s: &mut Session, i: usize, n: usize, cols: u32, old: Option<wordcraft_doc::section::SectionProps>) -> Result<(), CmdError> {
+    let last = i + n;
+    if cols > 1 && n > 0 {
+        // A paragraph after the index keeps the following section from being empty.
+        if last + 1 >= s.doc.body.len() {
+            s.doc.insert_block(StoryRef::Body, &Path::top(last + 1), Block::Para(Paragraph::new()))?;
+        }
+        let after = s.doc.sections().get(s.doc.section_index_of(last + 1)).map(|(_, x)| (*x).clone()).unwrap_or_default();
+        let head = s.doc.para_mut(StoryRef::Body, &Path::top(i))?;
+        let new = head.section.is_none();
+        if new {
+            head.section = Some(Box::new(after.clone()));
+        }
+        let mut sect = old.unwrap_or_else(|| after.clone());
+        sect.columns.count = cols;
+        sect.columns.widths.clear();
+        sect.start = SectionStart::Continuous;
+        sect.page_num_start = None;
+        let end = s.doc.para_mut(StoryRef::Body, &Path::top(last))?;
+        end.section = Some(Box::new(sect));
+        if new {
+            let rest = s.doc.section_mut(last + 1);
+            rest.start = SectionStart::Continuous;
+            rest.page_num_start = None;
+        }
+    } else if old.is_some() {
+        // Back to one column: the sections around the index join again, with the first one's start.
+        let head = s.doc.para_mut(StoryRef::Body, &Path::top(i))?;
+        if let Some(before) = head.section.take() {
+            head.touch();
+            let rest = s.doc.section_mut(i);
+            rest.start = before.start;
+            rest.page_num_start = before.page_num_start;
+        }
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn index_lines(s: &Session) -> Vec<String> {
+        s.doc.body.iter().filter_map(|b| b.as_para()).filter(|p| p.props.style.as_deref() == Some(ENTRY_STYLE)).map(|p| p.plain_text()).collect()
+    }
+
+    /// #402: Mark Entry writes XE switches (subentry, bold page, cross-reference, Mark All) and
+    /// the INDEX field's switches change the index: run-in subentries, letter headings, a tab
+    /// before right-aligned page numbers, and two columns in a continuous section.
+    #[test]
+    fn index_switches_shape_the_index() {
+        let mut s = Session::new(wordcraft_doc::Document::from_text("Kilns are hot.\nGlaze the kilns.\nKilns again.\nPresses."));
+        s.run("select.text", &json!({"text": "Kilns"})).unwrap();
+        s.run("references.markEntry", &json!({"subentry": "firing", "bold": true})).unwrap();
+        s.run("select.text", &json!({"text": "Presses"})).unwrap();
+        s.run("references.markEntry", &json!({"crossReference": "See Kilns"})).unwrap();
+        let all = s.run("references.markEntry", &json!({"entry": "Kilns", "text": "Kilns", "all": true})).unwrap();
+        assert_eq!(all["marked"], 2, "the paragraphs with a whole-word, same-case match");
+        let instrs: Vec<String> = s
+            .doc
+            .body
+            .iter()
+            .filter_map(|b| b.as_para())
+            .flat_map(|p| p.objects.iter())
+            .filter_map(|o| match o {
+                InlineObject::Field { instr, .. } => Some(instr.clone()),
+                _ => None,
+            })
+            .collect();
+        assert!(
+            instrs.contains(&"XE \"Kilns:firing\" \\b".to_string()) && instrs.contains(&"XE \"Presses\" \\t \"See Kilns\"".to_string()),
+            "{instrs:?}"
+        );
+        s.run("caret.docEnd", &json!({})).unwrap();
+        s.run("text.newParagraph", &json!({})).unwrap();
+        s.run("references.index", &json!({"type": "runIn", "rightAlign": true, "columns": 2, "tabLeader": "hyphen"})).unwrap();
+        let (i, instr) = index_field(&s).unwrap();
+        assert_eq!(instr, "INDEX \\h \"A\" \\c \"2\" \\e \"\t\" \\r");
+        assert_eq!(index_lines(&s), vec!["K", "Kilns\t1: firing, 1", "P", "Presses. See Kilns"]);
+        let entry = s.doc.body[i + 2].as_para().unwrap();
+        assert_eq!(entry.props.tabs.as_ref().unwrap()[0].leader, TabLeader::Hyphen);
+        assert!(entry.runs.iter().any(|r| r.props.bold == Some(true)), "the \\b page number is bold");
+        // The entries sit in a two-column continuous section.
+        let last = s.doc.body[i + 4].as_para().unwrap();
+        let sect = last.section.as_ref().expect("index section");
+        assert_eq!((sect.columns.count, sect.start), (2, SectionStart::Continuous));
+        // Indented again: subentries get lines of their own; the leader stays on update.
+        s.run("references.index", &json!({"columns": 1, "rightAlign": true})).unwrap();
+        assert_eq!(index_lines(&s), vec!["K", "Kilns\t1", "firing\t1", "P", "Presses. See Kilns"]);
+        assert!(s.doc.body.iter().filter_map(|b| b.as_para()).all(|p| p.section.is_none()), "one section again");
+        s.run("references.updateIndex", &json!({})).unwrap();
+        let (i, _) = index_field(&s).unwrap();
+        assert_eq!(s.doc.body[i + 2].as_para().unwrap().props.tabs.as_ref().unwrap()[0].leader, TabLeader::Hyphen);
+    }
+}
diff --git a/crates/engine/src/cmd/ink_shape.rs b/crates/engine/src/cmd/ink_shape.rs
new file mode 100644
index 0000000000..b7b3aa3a67
--- /dev/null
+++ b/crates/engine/src/cmd/ink_shape.rs
@@ -0,0 +1,325 @@
+//! Draw › Ink to Shape: a small geometric recogniser that tells whether a hand-drawn stroke is a
+//! straight line, a rectangle (or square), an ellipse (or circle), a triangle or another polygon
+//! of up to eight corners. Our own fit: an open stroke is a line when it stays close to the chord
+//! between its ends; a closed one is an ellipse when its points sit on the ellipse inscribed in
+//! its bounds (low RMS of the normalised radius), else a polygon from its corners (the closed
+//! path simplified with Ramer–Douglas–Peucker, near-straight and crowded corners merged) when
+//! that polygon stays close to every point. Anything else (scribbles, curves, letters) stays ink.
+
+use wordcraft_doc::freeform::MAX_POINTS;
+
+/// A shape recognised in a stroke, in the stroke's own coordinates.
+#[derive(Clone, Debug, PartialEq)]
+pub enum InkShape {
+    /// A straight line from `a` to `b`.
+    Line { a: [f32; 2], b: [f32; 2] },
+    /// An upright rectangle: top-left and size (equal sides when drawn nearly square).
+    Rectangle { x: f32, y: f32, w: f32, h: f32 },
+    /// An upright ellipse in this box (a circle when drawn nearly round).
+    Ellipse { x: f32, y: f32, w: f32, h: f32 },
+    /// A closed polygon through its 3–8 corners (a triangle has three).
+    Polygon(Vec<[f32; 2]>),
+}
+
+impl InkShape {
+    /// What it is, for messages and command results.
+    pub fn name(&self) -> &'static str {
+        match self {
+            InkShape::Line { .. } => "line",
+            InkShape::Rectangle { w, h, .. } if w == h => "square",
+            InkShape::Rectangle { .. } => "rectangle",
+            InkShape::Ellipse { w, h, .. } if w == h => "circle",
+            InkShape::Ellipse { .. } => "ellipse",
+            InkShape::Polygon(c) if c.len() == 3 => "triangle",
+            InkShape::Polygon(_) => "polygon",
+        }
+    }
+
+    /// Its bounds: left, top, width, height.
+    pub fn bounds(&self) -> [f32; 4] {
+        match self {
+            InkShape::Rectangle { x, y, w, h } | InkShape::Ellipse { x, y, w, h } => [*x, *y, *w, *h],
+            InkShape::Line { a, b } => bbox(&[*a, *b]),
+            InkShape::Polygon(c) => bbox(c),
+        }
+    }
+}
+
+/// Smallest stroke (its longer side, points) that is turned into a shape: a tap or a tick stays ink.
+const MIN_SIZE: f32 = 6.0;
+/// Most corners a polygon may have.
+pub const MAX_CORNERS: usize = 8;
+
+/// The shape `pts` draws, if it is one.
+pub fn recognise(pts: &[[f32; 2]]) -> Option<InkShape> {
+    // Finite points only, without repeats.
+    let mut p: Vec<[f32; 2]> = Vec::with_capacity(pts.len().min(MAX_POINTS));
+    for q in pts.iter().take(MAX_POINTS).filter(|[x, y]| x.is_finite() && y.is_finite() && x.abs() < 1e6 && y.abs() < 1e6) {
+        if p.last() != Some(q) {
+            p.push(*q);
+        }
+    }
+    let (first, last) = (*p.first()?, *p.last()?);
+    if p.len() < 2 {
+        return None;
+    }
+    let [x0, y0, w, h] = bbox(&p);
+    let size = w.max(h);
+    let diag = w.hypot(h);
+    if size < MIN_SIZE {
+        return None;
+    }
+    let length: f32 = p.windows(2).map(|s| s.first().zip(s.get(1)).map_or(0.0, |(a, b)| dist(*a, *b))).sum();
+    let gap = dist(first, last);
+    // A line: the stroke barely leaves the chord between its ends and doesn't double back.
+    if gap > 0.85 * length && gap >= MIN_SIZE {
+        let off = p.iter().map(|q| seg_distance(first, last, *q)).fold(0.0, f32::max);
+        if off <= (0.06 * gap).max(1.5) {
+            return Some(InkShape::Line { a: first, b: last });
+        }
+    }
+    // Other shapes are closed: the stroke ends near where it began and goes around.
+    if gap > 0.2 * size || length < 2.0 * size {
+        return None;
+    }
+    // Ellipse: the points sit on the ellipse inscribed in their bounds.
+    let ellipse_rms = ellipse_rms(&p, x0, y0, w, h);
+    if w > 0.2 * size && h > 0.2 * size && ellipse_rms < 0.06 {
+        let (x, y, w, h) = snap_square(x0, y0, w, h);
+        return Some(InkShape::Ellipse { x, y, w, h });
+    }
+    // Polygon: the corners of the closed path, if they describe it.
+    let corners = corners(&p, diag);
+    let fits = corners.len() >= 3 && p.iter().all(|q| polygon_distance(&corners, *q) <= 0.08 * diag);
+    if fits && corners.len() == 4 && upright(&corners) {
+        let [x, y, w, h] = bbox(&corners);
+        let (x, y, w, h) = snap_square(x, y, w, h);
+        return Some(InkShape::Rectangle { x, y, w, h });
+    }
+    if fits && corners.len() <= MAX_CORNERS {
+        return Some(InkShape::Polygon(corners));
+    }
+    // A wobbly round stroke is still an ellipse.
+    (w > 0.2 * size && h > 0.2 * size && ellipse_rms < 0.1).then(|| {
+        let (x, y, w, h) = snap_square(x0, y0, w, h);
+        InkShape::Ellipse { x, y, w, h }
+    })
+}
+
+/// Left, top, width and height of `pts` (zero for none).
+fn bbox(pts: &[[f32; 2]]) -> [f32; 4] {
+    let Some(f) = pts.first() else { return [0.0; 4] };
+    let (mut x0, mut y0, mut x1, mut y1) = (f[0], f[1], f[0], f[1]);
+    for [x, y] in pts {
+        (x0, y0, x1, y1) = (x0.min(*x), y0.min(*y), x1.max(*x), y1.max(*y));
+    }
+    [x0, y0, x1 - x0, y1 - y0]
+}
+
+fn dist(a: [f32; 2], b: [f32; 2]) -> f32 {
+    (b[0] - a[0]).hypot(b[1] - a[1])
+}
+
+/// Distance from `p` to the segment `a`–`b`.
+fn seg_distance(a: [f32; 2], b: [f32; 2], p: [f32; 2]) -> f32 {
+    let (dx, dy) = (b[0] - a[0], b[1] - a[1]);
+    let len2 = dx * dx + dy * dy;
+    let t = if len2 > 0.0 { (((p[0] - a[0]) * dx + (p[1] - a[1]) * dy) / len2).clamp(0.0, 1.0) } else { 0.0 };
+    dist([a[0] + t * dx, a[1] + t * dy], p)
+}
+
+/// Distance from `p` to the closed polygon through `c`.
+fn polygon_distance(c: &[[f32; 2]], p: [f32; 2]) -> f32 {
+    let n = c.len();
+    (0..n).filter_map(|i| Some(seg_distance(*c.get(i)?, *c.get((i + 1) % n)?, p))).fold(f32::INFINITY, f32::min)
+}
+
+/// How far the points stray from the ellipse inscribed in the `w` × `h` box at (`x0`, `y0`): the
+/// RMS of each point's normalised radius minus one (0 on the ellipse).
+fn ellipse_rms(p: &[[f32; 2]], x0: f32, y0: f32, w: f32, h: f32) -> f32 {
+    let (rx, ry) = (w / 2.0, h / 2.0);
+    if rx <= 0.0 || ry <= 0.0 || p.is_empty() {
+        return f32::INFINITY;
+    }
+    let (cx, cy) = (x0 + rx, y0 + ry);
+    let sum: f32 = p.iter().map(|[x, y]| (((x - cx) / rx).hypot((y - cy) / ry) - 1.0).powi(2)).sum();
+    (sum / p.len() as f32).sqrt()
+}
+
+/// A box drawn nearly square made square (same centre).
+fn snap_square(x: f32, y: f32, w: f32, h: f32) -> (f32, f32, f32, f32) {
+    if (w - h).abs() <= 0.12 * w.max(h) {
+        let s = (w + h) / 2.0;
+        (x + (w - s) / 2.0, y + (h - s) / 2.0, s, s)
+    } else {
+        (x, y, w, h)
+    }
+}
+
+/// The corners of the closed path through `p`: simplified with Ramer–Douglas–Peucker (split
+/// at the point farthest from the start), then corners that barely turn or crowd a neighbour
+/// merged away.
+fn corners(p: &[[f32; 2]], diag: f32) -> Vec<[f32; 2]> {
+    let eps = 0.05 * diag;
+    let Some(&start) = p.first() else { return Vec::new() };
+    let far = p.iter().enumerate().fold((0, 0.0), |best, (i, q)| if dist(start, *q) > best.1 { (i, dist(start, *q)) } else { best }).0;
+    let (a, b) = p.split_at(far.min(p.len()));
+    let mut ring: Vec<[f32; 2]> = rdp(&[a, b.get(..1).unwrap_or(&[])].concat(), eps);
+    let mut back = rdp(&[b, &[start]].concat(), eps);
+    // The halves share the far point and the start.
+    ring.pop();
+    back.pop();
+    ring.extend(back);
+    // Merge until every corner turns sharply and none sits on top of the next.
+    while ring.len() > 3 {
+        let n = ring.len();
+        let turn = |i: usize| -> f32 {
+            let (Some(a), Some(b), Some(c)) = (ring.get((i + n - 1) % n), ring.get(i), ring.get((i + 1) % n)) else { return 0.0 };
+            turning(*a, *b, *c)
+        };
+        let (i, t) = (0..n).map(|i| (i, turn(i))).fold((0, f32::INFINITY), |m, x| if x.1 < m.1 { x } else { m });
+        let short = (0..n).find(|&j| ring.get(j).zip(ring.get((j + 1) % n)).is_some_and(|(a, b)| dist(*a, *b) < 0.1 * diag));
+        if t < 30.0 {
+            ring.remove(i);
+        } else if let Some(j) = short {
+            // Of the two crowded corners keep the sharper.
+            let k = if turn(j) < turn((j + 1) % n) { j } else { (j + 1) % n };
+            ring.remove(k);
+        } else {
+            break;
+        }
+    }
+    ring
+}
+
+/// How far the path turns at `b` coming from `a` and going on to `c`, degrees (0 = straight on).
+fn turning(a: [f32; 2], b: [f32; 2], c: [f32; 2]) -> f32 {
+    let (u, v) = ([b[0] - a[0], b[1] - a[1]], [c[0] - b[0], c[1] - b[1]]);
+    let (lu, lv) = (u[0].hypot(u[1]), v[0].hypot(v[1]));
+    if lu <= 0.0 || lv <= 0.0 {
+        return 0.0;
+    }
+    ((u[0] * v[0] + u[1] * v[1]) / (lu * lv)).clamp(-1.0, 1.0).acos().to_degrees()
+}
+
+/// Ramer–Douglas–Peucker simplification of an open path (iterative: no deep recursion on long
+/// strokes); keeps both ends.
+fn rdp(p: &[[f32; 2]], eps: f32) -> Vec<[f32; 2]> {
+    let n = p.len();
+    if n < 3 {
+        return p.to_vec();
+    }
+    let mut keep = vec![false; n];
+    if let Some(f) = keep.first_mut() {
+        *f = true;
+    }
+    if let Some(l) = keep.last_mut() {
+        *l = true;
+    }
+    let mut stack = vec![(0usize, n - 1)];
+    while let Some((a, b)) = stack.pop() {
+        let (Some(&pa), Some(&pb)) = (p.get(a), p.get(b)) else { continue };
+        let far = (a + 1..b).filter_map(|i| Some((i, seg_distance(pa, pb, *p.get(i)?)))).fold((a, 0.0), |m, x| if x.1 > m.1 { x } else { m });
+        if far.1 > eps
+            && let Some(k) = keep.get_mut(far.0)
+        {
+            *k = true;
+            stack.push((a, far.0));
+            stack.push((far.0, b));
+        }
+    }
+    p.iter().zip(keep).filter(|(_, k)| *k).map(|(q, _)| *q).collect()
+}
+
+/// A quadrilateral whose sides run (nearly) across and down the page, alternately.
+fn upright(c: &[[f32; 2]]) -> bool {
+    let n = c.len();
+    let dirs: Vec<Option<bool>> = (0..n)
+        .map(|i| {
+            let (a, b) = (c.get(i)?, c.get((i + 1) % n)?);
+            let deg = (b[1] - a[1]).atan2(b[0] - a[0]).to_degrees().rem_euclid(180.0);
+            // true: across, false: down; None when it's slanted.
+            if deg <= 15.0 || deg >= 165.0 {
+                Some(true)
+            } else if (75.0..=105.0).contains(&deg) {
+                Some(false)
+            } else {
+                None
+            }
+        })
+        .collect();
+    dirs.iter().all(Option::is_some) && (0..n).all(|i| dirs.get(i) != dirs.get((i + 1) % n))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Points along a closed polygon, `per` to a side, with a little deterministic hand wobble.
+    fn around(corners: &[[f32; 2]], per: usize) -> Vec<[f32; 2]> {
+        let mut out = Vec::new();
+        for (i, a) in corners.iter().enumerate() {
+            let b = corners[(i + 1) % corners.len()];
+            for k in 0..per {
+                let t = k as f32 / per as f32;
+                let wob = (out.len() as f32 * 1.7).sin() * 0.6;
+                out.push([a[0] + (b[0] - a[0]) * t + wob, a[1] + (b[1] - a[1]) * t - wob]);
+            }
+        }
+        out.push(corners[0]);
+        out
+    }
+
+    #[test]
+    fn rectangles_ellipses_lines_and_triangles_are_recognised() {
+        // A rectangle, started mid-side as people often do.
+        let rect = around(&[[50.0, 10.0], [110.0, 10.0], [110.0, 70.0 + 0.0], [10.0, 70.0], [10.0, 10.0]], 12);
+        let Some(InkShape::Rectangle { x, y, w, h }) = recognise(&rect) else { panic!("{:?}", recognise(&rect)) };
+        assert!((x - 10.0).abs() < 2.0 && (y - 10.0).abs() < 2.0 && (w - 100.0).abs() < 3.0 && (h - 60.0).abs() < 3.0, "{x} {y} {w} {h}");
+        // Nearly square: a square.
+        assert_eq!(recognise(&around(&[[0.0, 0.0], [60.0, 0.0], [60.0, 57.0], [0.0, 57.0]], 10)).map(|s| s.name()), Some("square"));
+        // An ellipse and a circle.
+        let ring = |rx: f32, ry: f32| {
+            (0..=64).map(|i| (i as f32 / 64.0) * std::f32::consts::TAU).map(|a| [100.0 + rx * a.cos(), 80.0 + ry * a.sin()]).collect::<Vec<_>>()
+        };
+        let Some(InkShape::Ellipse { x, w, h, .. }) = recognise(&ring(40.0, 25.0)) else { panic!() };
+        assert!((x - 60.0).abs() < 0.5 && (w - 80.0).abs() < 0.5 && (h - 50.0).abs() < 0.5);
+        assert_eq!(recognise(&ring(30.0, 29.0)).map(|s| s.name()), Some("circle"));
+        // A slightly shaky line keeps its ends.
+        let line: Vec<[f32; 2]> = (0..=40).map(|i| i as f32).map(|t| [10.0 + t * 3.0, 20.0 + t + (t * 2.1).sin() * 0.8]).collect();
+        assert_eq!(recognise(&line), Some(InkShape::Line { a: line[0], b: line[40] }));
+        // A triangle and a pentagon.
+        let tri = around(&[[0.0, 80.0], [45.0, 0.0], [90.0, 80.0]], 15);
+        let Some(InkShape::Polygon(c)) = recognise(&tri) else { panic!("{:?}", recognise(&tri)) };
+        assert_eq!(c.len(), 3);
+        let penta: Vec<[f32; 2]> = (0..5)
+            .map(|i| (i as f32 / 5.0) * std::f32::consts::TAU - std::f32::consts::FRAC_PI_2)
+            .map(|a| [60.0 + 50.0 * a.cos(), 60.0 + 50.0 * a.sin()])
+            .collect();
+        assert_eq!(recognise(&around(&penta, 12)).map(|s| s.name()), Some("polygon"));
+    }
+
+    #[test]
+    fn scribbles_ticks_and_hostile_points_stay_ink() {
+        // An open zigzag, a hook, a tap and a tiny tick.
+        let zigzag: Vec<[f32; 2]> = (0..20).map(|i| [i as f32 * 8.0, if i % 2 == 0 { 0.0 } else { 30.0 }]).collect();
+        assert_eq!(recognise(&zigzag), None);
+        assert_eq!(recognise(&[[0.0, 0.0], [50.0, 0.0], [50.0, 50.0]]), None);
+        assert_eq!(recognise(&[[5.0, 5.0]]), None);
+        assert_eq!(recognise(&[[0.0, 0.0], [2.0, 3.0]]), None);
+        // A closed scribble with many spikes: not a polygon of eight or fewer corners, not round.
+        let star: Vec<[f32; 2]> = (0..=24)
+            .map(|i| {
+                let a = i as f32 / 24.0 * std::f32::consts::TAU;
+                let r = if i % 2 == 0 { 60.0 } else { 20.0 };
+                [80.0 + r * a.cos(), 80.0 + r * a.sin()]
+            })
+            .collect();
+        assert_eq!(recognise(&star), None);
+        // NaN, infinities and a flood of points never panic.
+        let mut junk = vec![[f32::NAN, 1.0], [f32::INFINITY, 2.0], [3.0, f32::NEG_INFINITY]];
+        junk.extend(std::iter::repeat_n([1.0, 1.0], MAX_POINTS * 3));
+        assert_eq!(recognise(&junk), None);
+        assert_eq!(recognise(&[]), None);
+    }
+}
diff --git a/crates/engine/src/cmd/insert.rs b/crates/engine/src/cmd/insert.rs
index d33144baa8..9d84e5f812 100644
--- a/crates/engine/src/cmd/insert.rs
+++ b/crates/engine/src/cmd/insert.rs
@@ -28,7 +28,7 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("insert.icon", "Icons", "Insert › Illustrations", icon)
             .params(r#"{"id"?: string (omit to list the library), "color"?: "RRGGBB", "size"?: pt, "query"?: string, "category"?: string}"#),
         CommandSpec::new("insert.shape", "Shapes", "Insert › Illustrations", shape)
-            .params(r#"{"kind": "rectangle|roundedRectangle|ellipse|triangle|diamond|line|arrow|star|heart", "width"?: pt, "height"?: pt, "fill"?: "RRGGBB", "stroke"?: "RRGGBB"}"#),
+            .params(r#"{"kind": "rectangle|roundedRectangle|ellipse|triangle|diamond|line|arrow|star|heart|straightConnector|elbowConnector|curvedConnector", "width"?: pt, "height"?: pt, "fill"?: "RRGGBB", "stroke"?: "RRGGBB", "arrow"?: "none"|"start"|"end"|"both" (lines and connectors; glue a connector's ends with shape.connect)}"#),
         CommandSpec::new("insert.textBox", "Text Box", "Insert › Text", text_box)
             .params(r#"{"text"?: string, "width"?: pt, "height"?: pt}"#)
             .when(|s| {
@@ -90,14 +90,6 @@ pub fn specs() -> Vec<CommandSpec> {
                 p.borders = Some(wordcraft_doc::props::Borders { bottom: Some(wordcraft_doc::props::Border::single(1.5)), ..Default::default() })
             })
         }),
-        CommandSpec::new("insert.wordArt", "WordArt", "Insert › Text", |s, v| {
-            let text = p::str(v, "text").unwrap_or("Your text here").to_string();
-            let props = CharProps { size: Some(36.0), bold: Some(true), color: Some(TextColor::Rgb(Rgb(0x15, 0x60, 0x82))), outline: Some(false), ..Default::default() };
-            let at = delete_selection(s)?;
-            let end = s.doc.insert_text(&at, &text, &props)?;
-            s.sel = Selection { anchor: at, focus: end };
-            sel_result(s)
-        }),
         CommandSpec::new("insert.textFromFile", "Text from File", "Insert › Text › Object", |s, v| {
             let path = p::req_str(v, "path")?;
             let doc = crate::io::open_path(std::path::Path::new(path)).map_err(CmdError::Failed)?;
@@ -288,25 +280,31 @@ fn shape(s: &mut Session, v: &Value) -> CmdResult {
     let kind: ShapeKind =
         serde_json::from_value(v.get("kind").cloned().unwrap_or(json!("rectangle"))).map_err(|e| CmdError::Params(e.to_string()))?;
     let w = p::f32(v, "width").unwrap_or(108.0).clamp(4.0, 2000.0);
-    let h = p::f32(v, "height").unwrap_or(if kind == ShapeKind::Line { 1.0 } else { 72.0 }).clamp(1.0, 2000.0);
+    let h =
+        p::f32(v, "height").unwrap_or(if kind == ShapeKind::Line { 1.0 } else { 72.0 }).clamp(if kind.is_connector() { 0.0 } else { 1.0 }, 2000.0);
     let fill = match p::str(v, "fill") {
         Some(c) => Rgb::parse(c),
-        None if kind == ShapeKind::Line => None,
+        None if kind.is_open() => None,
         None => Some(Rgb(0x15, 0x60, 0x82)),
     };
-    let stroke = p::str(v, "stroke").and_then(Rgb::parse).or(Some(Rgb(0x0E, 0x40, 0x5A)));
-    let obj = InlineObject::Shape {
-        kind,
-        w,
-        h,
-        fill,
-        stroke,
-        stroke_width: 1.0,
-        float: Float { wrap: Wrap::Inline, ..Default::default() },
-        story: None,
-        freeform: None,
-        effects: Default::default(),
+    // Arrowheads on lines and connectors.
+    let (arrow_start, arrow_end) = match p::str(v, "arrow") {
+        Some("end") => (false, true),
+        Some("start") => (true, false),
+        Some("both") => (true, true),
+        Some("none") | None => (false, false),
+        Some(x) => return Err(CmdError::Params(format!("`arrow`: none, start, end or both, not `{x}`"))),
     };
+    let extra = wordcraft_doc::connector::ShapeExtra { arrow_start, arrow_end, ..Default::default() };
+    // Connectors float in front of the text, so they can be glued to floating shapes.
+    let float = if kind.is_connector() {
+        Float { wrap: Wrap::InFrontOfText, ..Default::default() }
+    } else {
+        Float { wrap: Wrap::Inline, ..Default::default() }
+    };
+    let stroke = p::str(v, "stroke").and_then(Rgb::parse).or(Some(Rgb(0x0E, 0x40, 0x5A)));
+    let obj =
+        InlineObject::Shape { kind, w, h, fill, stroke, stroke_width: 1.0, float, story: None, freeform: None, effects: Default::default(), extra };
     // A selected Drawing Canvas takes it in (and stays selected for the next one).
     if super::canvas::add_member(s, obj.clone())?.is_some() {
         return sel_result(s);
@@ -334,6 +332,7 @@ fn text_box(s: &mut Session, v: &Value) -> CmdResult {
         story: Some(id),
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     // A selected Drawing Canvas takes it in; otherwise it goes at the caret.
     if super::canvas::add_member(s, obj.clone())?.is_none() {
@@ -519,13 +518,16 @@ pub fn format_date(fmt: &str) -> String {
     let hh: u32 = iso.get(11..13).and_then(|x| x.parse().ok()).unwrap_or(0);
     let mm: u32 = iso.get(14..16).and_then(|x| x.parse().ok()).unwrap_or(0);
     let ss: u32 = iso.get(17..19).and_then(|x| x.parse().ok()).unwrap_or(0);
+    format_date_parts(fmt, y, m, d, (hh, mm, ss), (super::now_unix() / 86_400) as i64)
+}
+
+/// Format a date and time with a Word picture; `days_since` (days since 1970-01-01) gives the weekday.
+pub fn format_date_parts(fmt: &str, y: i64, m: usize, d: u32, (hh, mm, ss): (u32, u32, u32), days_since: i64) -> String {
     const MONTHS: [&str; 12] =
         ["January", "February", "March", "April", "May", "June", "July", "August", "September", "October", "November", "December"];
     const DAYS: [&str; 7] = ["Thursday", "Friday", "Saturday", "Sunday", "Monday", "Tuesday", "Wednesday"];
-    // Days since the epoch, for the weekday.
-    let days_since = (super::now_unix() / 86_400) as usize;
     let month = MONTHS.get(m.saturating_sub(1)).copied().unwrap_or("January");
-    let day = DAYS.get(days_since % 7).copied().unwrap_or("Monday");
+    let day = DAYS.get(days_since.rem_euclid(7) as usize).copied().unwrap_or("Monday");
     let mut out = String::new();
     let chars: Vec<char> = fmt.chars().collect();
     let mut i = 0;
diff --git a/crates/engine/src/cmd/lists.rs b/crates/engine/src/cmd/lists.rs
index 618b2272a6..e7f58cbce8 100644
--- a/crates/engine/src/cmd/lists.rs
+++ b/crates/engine/src/cmd/lists.rs
@@ -220,6 +220,8 @@ fn define(s: &mut Session, v: &Value) -> CmdResult {
             pp.numbering = Some(NumRef { num, level });
             pp.indent_left = None;
             pp.indent_first = None;
+            pp.indent_left_chars = None;
+            pp.indent_first_chars = None;
             if pp.style.is_none() || pp.style.as_deref() == Some("Normal") {
                 pp.style = Some("ListParagraph".into());
             }
diff --git a/crates/engine/src/cmd/mailings.rs b/crates/engine/src/cmd/mailings.rs
index 3ff6cb057d..ba66116191 100644
--- a/crates/engine/src/cmd/mailings.rs
+++ b/crates/engine/src/cmd/mailings.rs
@@ -136,10 +136,12 @@ pub fn specs() -> Vec<CommandSpec> {
             .params(r#"{"path"?: string (save the merged document), "from"?: n, "to"?: n}"#)
             .key(super::non_mac("Alt+Shift+N"))
             .when(has_recipients),
-        CommandSpec::new("mailings.envelopes", "Envelopes", "Mailings › Create", envelopes)
-            .params(r#"{"delivery": string, "return"?: string, "size"?: "Envelope #10|Envelope DL"}"#),
-        CommandSpec::new("mailings.labels", "Labels", "Mailings › Create", labels)
-            .params(r#"{"text"?: string, "rows"?: n, "cols"?: n, "fromRecipients"?: bool}"#),
+        CommandSpec::new("mailings.envelopes", "Envelopes", "Mailings › Create", envelopes).params(
+            r#"{"delivery": string, "return"?: string, "size"?: "Envelope #10|#9|Monarch|DL|C4|C5|C6|B5", "width"?: pt, "height"?: pt, "add"?: bool (add to this document instead of a new one)}"#,
+        ),
+        CommandSpec::new("mailings.labels", "Labels", "Mailings › Create", labels).params(
+            r#"{"text"?: string, "product"?: "letter-3x10|letter-2x10|letter-2x7|letter-2x5|letter-4x20|a4-3x7|a4-2x7|a4-3x8|a4-2x4", "rows"?: n, "cols"?: n, "fromRecipients"?: bool, "single"?: {"row": n, "col": n}}"#,
+        ),
     ]
 }
 
@@ -739,17 +741,41 @@ fn merge_blocks(s: &Session, blocks: &mut Blocks, cur: &mut usize, end: usize, d
     true
 }
 
+/// Common envelope sizes: name, width and height in points (long side first).
+pub const ENVELOPE_SIZES: [(&str, f32, f32); 8] = [
+    ("Envelope #10", 684.0, 297.0),
+    ("Envelope #9", 639.0, 279.0),
+    ("Envelope Monarch", 540.0, 279.0),
+    ("Envelope DL", 623.6, 311.8),
+    ("Envelope C4", 918.4, 649.1),
+    ("Envelope C5", 649.1, 459.2),
+    ("Envelope C6", 459.2, 323.1),
+    ("Envelope B5", 708.7, 498.9),
+];
+
+/// Envelope size by name (`Envelope DL`, or just `DL`, any case), or `width`/`height` in points.
+fn envelope_size(v: &Value) -> Result<(f32, f32), CmdError> {
+    if let (Some(w), Some(h)) = (p::f32(v, "width"), p::f32(v, "height")) {
+        let (w, h) = (w.clamp(144.0, 1584.0), h.clamp(144.0, 1584.0));
+        return Ok((w.max(h), w.min(h)));
+    }
+    let name = p::str(v, "size").unwrap_or("Envelope #10").trim();
+    ENVELOPE_SIZES
+        .iter()
+        .find(|(n, ..)| n.eq_ignore_ascii_case(name) || n.strip_prefix("Envelope ").is_some_and(|short| short.eq_ignore_ascii_case(name)))
+        .map(|(_, w, h)| (*w, *h))
+        .ok_or_else(|| CmdError::Params(format!("unknown envelope size `{name}`")))
+}
+
+/// Envelopes: a landscape page with the return address at the top left and the delivery address
+/// in the middle. As a new document, or (`add`) as a section of its own at the start of this one.
 fn envelopes(s: &mut Session, v: &Value) -> CmdResult {
     let delivery = p::str(v, "delivery").map(str::to_string).unwrap_or_else(|| {
         if s.merge.rows.is_empty() { "Recipient Name\nStreet Address\nCity, ST 00000".into() } else { address_block(s, s.merge.record) }
     });
     let ret = p::str(v, "return").unwrap_or("").to_string();
-    let (w, h) = match p::str(v, "size").unwrap_or("Envelope #10") {
-        "Envelope DL" => (623.6, 311.8),
-        _ => (684.0, 297.0),
-    };
-    let mut d = Document::new();
-    d.last_section = SectionProps {
+    let (w, h) = envelope_size(v)?;
+    let sect = SectionProps {
         page_w: w,
         page_h: h,
         landscape: true,
@@ -759,55 +785,262 @@ fn envelopes(s: &mut Session, v: &Value) -> CmdResult {
         margin_bottom: 22.0,
         ..Default::default()
     };
+    // Addresses are capped: a pasted novel is not an address.
+    let lines = |t: &str| t.split('\n').take(20).map(str::to_string).collect::<Vec<_>>();
     let mut blocks = Vec::new();
-    for l in ret.split('\n') {
+    let ret_lines = if ret.is_empty() { Vec::new() } else { lines(&ret) };
+    for l in &ret_lines {
         blocks.push(para_block(Paragraph::with_text(l, CharProps { size: Some(10.0), ..Default::default() }).styled("NoSpacing")));
     }
-    let spacer = (6 - ret.lines().count().min(6)).max(1);
+    let spacer = (6 - ret_lines.len().min(6)).max(1);
     for _ in 0..spacer + 2 {
         blocks.push(para_block(Paragraph::new().styled("NoSpacing")));
     }
-    for l in delivery.split('\n') {
-        let mut p = Paragraph::with_text(l, CharProps::default()).styled("NoSpacing");
+    let mut last = None;
+    for l in lines(&delivery) {
+        let mut p = Paragraph::with_text(&l, CharProps::default()).styled("NoSpacing");
         p.props.indent_left = Some(w * 0.42);
-        blocks.push(para_block(p));
+        if let Some(prev) = last.replace(p) {
+            blocks.push(para_block(prev));
+        }
     }
+    if p::bool(v, "add") == Some(true) {
+        // The envelope's own section ends with its last address line.
+        let mut end = last.unwrap_or_else(|| Paragraph::new().styled("NoSpacing"));
+        end.section = Some(Box::new(sect));
+        blocks.push(para_block(end));
+        let n = blocks.len();
+        s.doc.body.splice(0..0, blocks);
+        s.sel = Selection::caret(s.doc.start_of(StoryRef::Body));
+        return Ok(json!({"width": w, "height": h, "added": n}));
+    }
+    blocks.extend(last.map(para_block));
+    let mut d = Document::new();
+    d.last_section = sect;
     d.body = blocks;
     s.set_document(d);
     s.path = None;
     Ok(json!({"width": w, "height": h}))
 }
 
+/// A sheet of labels: the label size, how many across and down, and where the first one sits.
+/// Lengths in points; the pitch is from one label's edge to the next one's.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct LabelProduct {
+    pub id: &'static str,
+    /// What the labels are for: `address`, `shipping` or `return`.
+    pub kind: &'static str,
+    /// Letter or A4.
+    pub paper: &'static str,
+    pub cols: usize,
+    pub rows: usize,
+    pub width: f32,
+    pub height: f32,
+    pub top: f32,
+    pub side: f32,
+    pub h_pitch: f32,
+    pub v_pitch: f32,
+}
+
+const MM: f32 = 72.0 / 25.4;
+
+/// Common label sheets (the sizes are the industry's; the names are ours).
+pub const LABEL_PRODUCTS: [LabelProduct; 9] = [
+    LabelProduct {
+        id: "letter-3x10",
+        kind: "address",
+        paper: "Letter",
+        cols: 3,
+        rows: 10,
+        width: 189.0,
+        height: 72.0,
+        top: 36.0,
+        side: 13.5,
+        h_pitch: 198.0,
+        v_pitch: 72.0,
+    },
+    LabelProduct {
+        id: "letter-2x10",
+        kind: "address",
+        paper: "Letter",
+        cols: 2,
+        rows: 10,
+        width: 288.0,
+        height: 72.0,
+        top: 36.0,
+        side: 11.25,
+        h_pitch: 301.5,
+        v_pitch: 72.0,
+    },
+    LabelProduct {
+        id: "letter-2x7",
+        kind: "address",
+        paper: "Letter",
+        cols: 2,
+        rows: 7,
+        width: 288.0,
+        height: 96.0,
+        top: 60.0,
+        side: 11.25,
+        h_pitch: 301.5,
+        v_pitch: 96.0,
+    },
+    LabelProduct {
+        id: "letter-2x5",
+        kind: "shipping",
+        paper: "Letter",
+        cols: 2,
+        rows: 5,
+        width: 288.0,
+        height: 144.0,
+        top: 36.0,
+        side: 11.25,
+        h_pitch: 301.5,
+        v_pitch: 144.0,
+    },
+    LabelProduct {
+        id: "letter-4x20",
+        kind: "return",
+        paper: "Letter",
+        cols: 4,
+        rows: 20,
+        width: 126.0,
+        height: 36.0,
+        top: 36.0,
+        side: 21.6,
+        h_pitch: 147.6,
+        v_pitch: 36.0,
+    },
+    LabelProduct {
+        id: "a4-3x7",
+        kind: "address",
+        paper: "A4",
+        cols: 3,
+        rows: 7,
+        width: 63.5 * MM,
+        height: 38.1 * MM,
+        top: 15.15 * MM,
+        side: 7.21 * MM,
+        h_pitch: 66.04 * MM,
+        v_pitch: 38.1 * MM,
+    },
+    LabelProduct {
+        id: "a4-2x7",
+        kind: "address",
+        paper: "A4",
+        cols: 2,
+        rows: 7,
+        width: 99.1 * MM,
+        height: 38.1 * MM,
+        top: 15.15 * MM,
+        side: 4.65 * MM,
+        h_pitch: 101.6 * MM,
+        v_pitch: 38.1 * MM,
+    },
+    LabelProduct {
+        id: "a4-3x8",
+        kind: "address",
+        paper: "A4",
+        cols: 3,
+        rows: 8,
+        width: 63.5 * MM,
+        height: 33.9 * MM,
+        top: 12.9 * MM,
+        side: 7.21 * MM,
+        h_pitch: 66.04 * MM,
+        v_pitch: 33.9 * MM,
+    },
+    LabelProduct {
+        id: "a4-2x4",
+        kind: "shipping",
+        paper: "A4",
+        cols: 2,
+        rows: 4,
+        width: 99.1 * MM,
+        height: 67.7 * MM,
+        top: 13.1 * MM,
+        side: 4.65 * MM,
+        h_pitch: 101.6 * MM,
+        v_pitch: 67.7 * MM,
+    },
+];
+
+impl LabelProduct {
+    pub fn by_id(id: &str) -> Option<&'static LabelProduct> {
+        LABEL_PRODUCTS.iter().find(|p| p.id == id)
+    }
+    /// Label size as people say it: inches on Letter, millimetres on A4.
+    pub fn size_text(&self) -> String {
+        if self.paper == "A4" {
+            format!("{:.1} × {:.1} mm", self.width / MM, self.height / MM)
+        } else {
+            let i = |pt: f32| format!("{}", ((pt / 72.0) * 1000.0).round() / 1000.0);
+            format!("{}\" × {}\"", i(self.width), i(self.height))
+        }
+    }
+}
+
+/// Labels: a new document with a table of labels laid out like the sheet (`product`; spacer
+/// columns and rows stand for the gaps). A full page of the same `text` (or one recipient per
+/// label), or (`single`: `{"row", "col"}`, from 1) one label at that place on the sheet.
 fn labels(s: &mut Session, v: &Value) -> CmdResult {
-    // A 3 × 10 sheet of 2.625" × 1" labels on Letter (a common layout).
-    let rows = p::u64(v, "rows").unwrap_or(10).clamp(1, 40) as usize;
-    let cols = p::u64(v, "cols").unwrap_or(3).clamp(1, 10) as usize;
-    let from_rec = p::bool(v, "fromRecipients").unwrap_or(!s.merge.rows.is_empty() && p::str(v, "text").is_none());
+    let prod = match p::str(v, "product") {
+        Some(id) => *LabelProduct::by_id(id).ok_or_else(|| CmdError::Params(format!("unknown label product `{id}`")))?,
+        None => LABEL_PRODUCTS[0],
+    };
+    let rows = p::u64(v, "rows").map_or(prod.rows, |n| n.clamp(1, 40) as usize);
+    let cols = p::u64(v, "cols").map_or(prod.cols, |n| n.clamp(1, 10) as usize);
+    let single = v.get("single").filter(|x| !x.is_null()).map(|x| {
+        let at = |k: &str| x.get(k).and_then(Value::as_u64).unwrap_or(1).max(1) as usize;
+        (at("row").min(rows), at("col").min(cols))
+    });
+    let from_rec = single.is_none() && p::bool(v, "fromRecipients").unwrap_or(!s.merge.rows.is_empty() && p::str(v, "text").is_none());
     let text = p::str(v, "text").unwrap_or("Name\nAddress\nCity, ST 00000").to_string();
+    let (page_w, page_h) = if prod.paper == "A4" { (595.3, 841.9) } else { (612.0, 792.0) };
+    let h_gap = (prod.h_pitch - prod.width).max(0.0);
+    let v_gap = (prod.v_pitch - prod.height).max(0.0);
     let mut d = Document::new();
-    d.last_section.margin_top = 36.0;
+    d.last_section.page_w = page_w;
+    d.last_section.page_h = page_h;
+    d.last_section.margin_top = prod.top;
     d.last_section.margin_bottom = 0.0;
-    d.last_section.margin_left = 13.5;
-    d.last_section.margin_right = 13.5;
-    let mut t = Table::new(rows, cols, 189.0 * cols as f32);
+    d.last_section.margin_left = prod.side;
+    d.last_section.margin_right = (page_w - prod.side - prod.h_pitch * (cols - 1) as f32 - prod.width).max(0.0);
+    d.last_section.header = 0.0;
+    d.last_section.footer = 0.0;
+    // Grid columns: label, gap, label, …; rows likewise.
+    let grid_cols: Vec<Option<usize>> = (0..cols).flat_map(|c| [Some(c)].into_iter().chain((c + 1 < cols && h_gap > 0.5).then_some(None))).collect();
+    let grid_rows: Vec<Option<usize>> = (0..rows).flat_map(|r| [Some(r)].into_iter().chain((r + 1 < rows && v_gap > 0.5).then_some(None))).collect();
+    let width: f32 = grid_cols.iter().map(|c| if c.is_some() { prod.width } else { h_gap }).sum();
+    let mut t = Table::new(grid_rows.len(), grid_cols.len(), width);
     t.props.style = None;
     t.props.borders = Some(wordcraft_doc::props::Borders::default());
     t.props.fixed = true;
+    t.grid = grid_cols.iter().map(|c| if c.is_some() { prod.width } else { h_gap }).collect();
     let mut k = 0usize;
-    for r in &mut t.rows {
-        r.props.height = Some(72.0);
-        r.props.height_rule = wordcraft_doc::props::HeightRule::Exact;
-        for c in &mut r.cells {
-            let content = if from_rec {
-                let rec = address_block(s, k);
-                k += 1;
-                if k > s.merge.rows.len() { String::new() } else { rec }
-            } else {
-                text.clone()
+    let mut made = 0usize;
+    for (row, r) in t.rows.iter_mut().zip(&grid_rows) {
+        row.props.height = Some(if r.is_some() { prod.height } else { v_gap });
+        row.props.height_rule = wordcraft_doc::props::HeightRule::Exact;
+        for (cell, c) in row.cells.iter_mut().zip(&grid_cols) {
+            cell.props.width = Some(if c.is_some() { prod.width } else { h_gap });
+            let (Some(r), Some(c)) = (r, c) else { continue };
+            let content = match single {
+                Some((sr, sc)) if (sr, sc) != (r + 1, c + 1) => String::new(),
+                _ if from_rec => {
+                    let rec = if k < s.merge.rows.len() { address_block(s, k) } else { String::new() };
+                    k += 1;
+                    rec
+                }
+                _ => text.clone(),
             };
-            c.props.valign = wordcraft_doc::props::VAlign::Center;
-            c.blocks = content
+            if !content.is_empty() {
+                made += 1;
+            }
+            cell.props.valign = wordcraft_doc::props::VAlign::Center;
+            cell.blocks = content
                 .split('\n')
+                .take(20)
                 .map(|l| {
                     let mut p = Paragraph::with_text(l, CharProps::default()).styled("NoSpacing");
                     p.props.align = Some(Align::Left);
@@ -821,7 +1054,7 @@ fn labels(s: &mut Session, v: &Value) -> CmdResult {
     s.set_document(d);
     s.path = None;
     let _ = Pos::body(0, 0);
-    Ok(json!({"labels": rows * cols}))
+    Ok(json!({"labels": if single.is_some() { 1 } else { rows * cols }, "filled": made, "product": prod.id}))
 }
 
 #[cfg(test)]
@@ -1023,4 +1256,33 @@ mod tests {
         s.run("mailings.labels", &json!({"text": "Hello"})).unwrap();
         assert!(s.doc.plain_text(StoryRef::Body).matches("Hello").count() == 30);
     }
+
+    /// #407: Envelopes adds an envelope section of the chosen size before the letter; Labels
+    /// lays out a sheet of the chosen product, or a single label at a row and column.
+    #[test]
+    fn envelope_sizes_add_to_document_and_label_products() {
+        let mut s = Session::new(Document::from_text("Dear Jo,"));
+        let r = s.run("mailings.envelopes", &json!({"delivery": "Jo Doe\n1 Main St", "return": "Me", "size": "C5", "add": true})).unwrap();
+        assert_eq!((r["width"].as_f64().map(|w| w.round()), r["height"].as_f64().map(|h| h.round())), (Some(649.0), Some(459.0)));
+        let secs = s.doc.sections();
+        assert_eq!(secs.len(), 2, "an envelope section of its own");
+        assert!(secs[0].1.landscape && (secs[0].1.page_w - 649.1).abs() < 0.1);
+        let text = s.doc.plain_text(StoryRef::Body);
+        assert!(text.starts_with("Me") && text.contains("1 Main St") && text.trim_end().ends_with("Dear Jo,"), "{text}");
+        assert!(s.run("mailings.envelopes", &json!({"size": "Envelope X"})).is_err());
+
+        let r = s.run("mailings.labels", &json!({"text": "Ada", "product": "a4-2x7"})).unwrap();
+        assert_eq!(r["labels"], 14);
+        assert!((s.doc.last_section.page_w - 595.3).abs() < 0.1, "A4 sheet");
+        let Some(Block::Table(t)) = s.doc.body.first().map(|b| &**b) else { panic!("no table") };
+        assert_eq!((t.rows.len(), t.grid.len()), (7, 3), "two label columns and the gap between");
+        assert_eq!(s.doc.plain_text(StoryRef::Body).matches("Ada").count(), 14);
+        let r = s.run("mailings.labels", &json!({"text": "Bo", "product": "letter-3x10", "single": {"row": 2, "col": 3}})).unwrap();
+        assert_eq!(r["filled"], 1);
+        let Some(Block::Table(t)) = s.doc.body.first().map(|b| &**b) else { panic!("no table") };
+        // Row 2, column 3 (grid column 5: label, gap, label, gap, label).
+        let cell = t.rows.get(1).and_then(|r| r.cells.get(4)).and_then(|c| c.blocks.first());
+        assert!(matches!(cell.map(|b| &**b), Some(Block::Para(p)) if p.text == "Bo"));
+        assert!(s.run("mailings.labels", &json!({"product": "nope"})).is_err());
+    }
 }
diff --git a/crates/engine/src/cmd/mod.rs b/crates/engine/src/cmd/mod.rs
index 758787d10c..ab23672a69 100644
--- a/crates/engine/src/cmd/mod.rs
+++ b/crates/engine/src/cmd/mod.rs
@@ -1,36 +1,51 @@
 //! Command implementations, one module per area. Each module exposes `specs()`.
 
+pub mod accessibility;
 pub mod canvas;
 pub mod caret;
+pub mod chart;
 pub mod citations;
 pub mod column;
+pub mod connectors;
+pub mod controls;
 pub mod design;
 pub mod draw;
 pub mod edit;
 pub mod equation;
 pub mod fields;
 pub mod file;
+pub mod find_pattern;
 pub mod fmt_revisions;
+pub mod font;
 pub mod format;
+pub mod index;
+pub mod ink_shape;
 pub mod insert;
 pub mod inspector;
 pub mod lists;
 pub mod mailings;
 pub mod moves;
 pub mod objects;
+pub mod options;
+pub mod outline;
 pub mod page;
 pub mod para;
 pub mod paste;
 pub mod phonetic;
+pub mod protect;
 pub mod references;
 pub mod review;
+pub mod smart_art;
 pub mod speech;
 pub mod table;
 pub mod table_draw;
+pub mod table_resize;
 pub mod table_style;
+pub mod templates;
 pub mod text;
 pub mod tools;
 pub mod view;
+pub mod wordart;
 
 use serde_json::{Value, json};
 use wordcraft_doc::props::CharProps;
@@ -47,29 +62,41 @@ pub fn registry() -> Registry {
     v.extend(edit::specs());
     v.extend(paste::specs());
     v.extend(format::specs());
+    v.extend(font::specs());
     v.extend(phonetic::specs());
     v.extend(para::specs());
     v.extend(lists::specs());
     v.extend(inspector::specs());
     v.extend(view::specs());
+    v.extend(outline::specs());
     v.extend(insert::specs());
     v.extend(equation::specs());
     v.extend(page::specs());
     v.extend(table::specs());
     v.extend(table_style::specs());
     v.extend(table_draw::specs());
+    v.extend(table_resize::specs());
     v.extend(review::specs());
     v.extend(file::specs());
+    v.extend(options::specs());
     v.extend(design::specs());
     v.extend(references::specs());
     v.extend(fields::specs());
     v.extend(mailings::specs());
     v.extend(citations::specs());
+    v.extend(index::specs());
     v.extend(objects::specs());
+    v.extend(smart_art::specs());
+    v.extend(chart::specs());
     v.extend(draw::specs());
     v.extend(canvas::specs());
+    v.extend(wordart::specs());
+    v.extend(connectors::specs());
     v.extend(tools::specs());
+    v.extend(templates::specs());
+    v.extend(protect::specs());
     v.extend(speech::specs());
+    v.extend(controls::specs());
     Registry::new(v)
 }
 
@@ -109,6 +136,7 @@ pub fn delete_selection(s: &mut Session) -> Result<Pos, CmdError> {
     if a == b {
         return Ok(a);
     }
+    controls::check_delete(s, &a, &b)?;
     let at = if s.doc.settings.track_changes { track_delete(s, &a, &b)? } else { s.doc.delete_range(&a, &b)? };
     s.sel = crate::Selection::caret(at.clone());
     Ok(at)
@@ -212,7 +240,22 @@ pub(crate) fn track_delete_as(s: &mut Session, a: &Pos, b: &Pos, rid: u32) -> Re
 
 /// Insert typed text at the caret (replacing the selection), with pending formatting and track changes.
 pub fn type_text(s: &mut Session, text: &str) -> Result<(), CmdError> {
+    insert_text(s, text, true)
+}
+
+/// Insert pasted plain text like [`type_text`], except that its paragraph separators are text
+/// being transferred, not Enter key presses: an empty list item between them stays (Enter on
+/// one would end the list).
+pub fn paste_text(s: &mut Session, text: &str) -> Result<(), CmdError> {
+    insert_text(s, text, false)
+}
+
+fn insert_text(s: &mut Session, text: &str, enter: bool) -> Result<(), CmdError> {
     let mut props = s.typing_props();
+    // Content controls: a placeholder is replaced, locked ones refuse.
+    if let Some(p) = controls::prepare_edit(s)? {
+        props = p;
+    }
     delete_selection(s)?;
     // Typed text is new: never deleted, and not a formatting change of the text around it.
     props.fmt_change = None;
@@ -227,7 +270,7 @@ pub fn type_text(s: &mut Session, text: &str) -> Result<(), CmdError> {
     let mut first = true;
     for part in text.split(['\r', '\u{2029}']) {
         if !first {
-            at = split_para(s, &at)?;
+            at = split_para_as(s, &at, enter)?;
         }
         first = false;
         let part = part.replace('\u{000B}', "\n");
@@ -252,15 +295,22 @@ pub fn leave_list(para: &mut wordcraft_doc::Paragraph) {
     }
     para.props.indent_left = None;
     para.props.indent_first = None;
+    para.props.indent_left_chars = None;
+    para.props.indent_first_chars = None;
     para.touch();
 }
 
 /// Split the paragraph at `at` like Enter does: an empty list paragraph leaves the list, the
 /// next paragraph gets the style's "next" style when Enter is at the end.
 pub fn split_para(s: &mut Session, at: &Pos) -> Result<Pos, CmdError> {
+    split_para_as(s, at, true)
+}
+
+/// [`split_para`]; without `enter` an empty list item is split like any other paragraph.
+fn split_para_as(s: &mut Session, at: &Pos, enter: bool) -> Result<Pos, CmdError> {
     // `num: 0` means "explicitly not in a list", so it isn't a list item.
     let (at_end, style, empty_list) = match s.doc.para_at(at) {
-        Some(p) => (at.off >= p.len(), p.props.style.clone(), p.props.numbering.filter(|n| n.num != 0 && p.is_empty())),
+        Some(p) => (at.off >= p.len(), p.props.style.clone(), p.props.numbering.filter(|n| enter && n.num != 0 && p.is_empty())),
         None => return Err(CmdError::Failed("no paragraph at caret".into())),
     };
     if let Some(n) = empty_list {
diff --git a/crates/engine/src/cmd/objects.rs b/crates/engine/src/cmd/objects.rs
index bbe4a11a0c..fc658de12e 100644
--- a/crates/engine/src/cmd/objects.rs
+++ b/crates/engine/src/cmd/objects.rs
@@ -28,9 +28,27 @@ fn has_floating(s: &Session) -> Option<&'static str> {
         _ => Some("select a floating picture or shape first"),
     }
 }
+/// Stories whose objects can be moved, resized and arranged: the body and headers/footers.
+/// Objects in table cells (deeper paths), notes and text boxes stay where their text is.
+fn movable_story(s: &Session, story: StoryRef) -> bool {
+    match story {
+        StoryRef::Body => true,
+        StoryRef::Part(id) => {
+            s.doc.parts.get(&id).is_some_and(|p| matches!(p.kind, wordcraft_doc::PartKind::Header | wordcraft_doc::PartKind::Footer))
+        }
+    }
+}
 /// Charts and diagrams are not written back on save yet, so their size, position and wrapping stay
 /// as imported: they can be selected and deleted, not moved, resized or arranged.
 const FROZEN: &str = "charts and diagrams can't be moved or resized yet";
+/// `has_movable` for Size: charts and SmartArt WordCraft can edit are laid out again at their
+/// new size.
+fn has_sizable(s: &Session) -> Option<&'static str> {
+    match selected(s) {
+        Some((_, InlineObject::Graphic { graphic, .. })) if graphic.chart.is_some() || graphic.smart_art.is_some() => None,
+        _ => has_movable(s),
+    }
+}
 /// `has_object` for the geometry commands: a chart or diagram is frozen.
 fn has_movable(s: &Session) -> Option<&'static str> {
     match selected(s) {
@@ -64,7 +82,7 @@ fn has_shape(s: &Session) -> Option<&'static str> {
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
-        CommandSpec::new("picture.size", "Size", "Picture Format › Size", size).params(r#"{"width"?: pt, "height"?: pt, "lockAspect"?: bool, "scale"?: percent}"#).when(has_movable),
+        CommandSpec::new("picture.size", "Size", "Picture Format › Size", size).params(r#"{"width"?: pt, "height"?: pt, "lockAspect"?: bool, "scale"?: percent}"#).when(has_sizable),
         CommandSpec::new("picture.crop", "Crop", "Picture Format › Size", |s, v| {
             let c = [p::f32(v, "left"), p::f32(v, "top"), p::f32(v, "right"), p::f32(v, "bottom")].map(|x| x.unwrap_or(0.0).clamp(0.0, 0.45));
             with_obj(s, |o| {
@@ -75,16 +93,16 @@ pub fn specs() -> Vec<CommandSpec> {
         })
         .params(r#"{"left"?, "top"?, "right"?, "bottom"? (fractions 0–0.45)}"#)
         .when(has_picture),
+        // Kept for scripts written before every object had alt text: `object.altText` on a picture.
         CommandSpec::new("picture.altText", "Alt Text", "Picture Format › Accessibility", |s, v| {
-            let t = p::req_str(v, "text")?.to_string();
-            with_obj(s, |o| {
-                if let InlineObject::Image { alt, .. } = o {
-                    *alt = t.clone();
-                }
-            })
+            p::req_str(v, "text")?;
+            alt_text(s, v)
         })
-        .params(r#"{"text": string}"#)
+        .params(r#"{"text": string, "title"?: string, "decorative"?: bool}"#)
         .when(has_picture),
+        CommandSpec::new("object.altText", "Alt Text", "Shape Format › Accessibility", alt_text)
+            .params(r#"{"text"?: string, "title"?: string, "decorative"?: bool} (the selected picture, shape, text box, group or chart)"#)
+            .when(has_object),
         CommandSpec::new("picture.corrections", "Corrections", "Picture Format › Adjust", |s, v| {
             let b = p::f32(v, "brightness").unwrap_or(0.0).clamp(-100.0, 100.0);
             let c = p::f32(v, "contrast").unwrap_or(0.0).clamp(-100.0, 100.0);
@@ -258,6 +276,9 @@ pub fn specs() -> Vec<CommandSpec> {
         })
         .params(r#"{"side": "bothSides|left|right|largest"}  (the sides of the selected Square, Tight or Through object text flows on; largest: the wider side, line by line)"#)
         .when(has_movable),
+        CommandSpec::new("arrange.moveWithText", "Move with Text", "Layout › Arrange › Wrap Text", |s, v| move_with_text(s, p::bool(v, "value").unwrap_or(true)))
+            .params(r#"{"value": bool}  (true: Move with Text, the floating object's vertical position follows its paragraph; false: Fix Position on Page. It stays where it is)"#)
+            .when(has_floating),
         CommandSpec::new("arrange.position", "Position", "Layout › Arrange", |s, v| {
             let preset = p::str(v, "preset").unwrap_or("middleCenter").to_string();
             let (x, y) = (p::f32(v, "x"), p::f32(v, "y"));
@@ -450,7 +471,7 @@ pub fn text_box_target(s: &Session) -> Option<(Pos, u32)> {
 }
 
 /// Change the target text box's text direction, alignment or link.
-fn set_text_body(s: &mut Session, f: impl Fn(&mut TextBody)) -> CmdResult {
+pub(crate) fn set_text_body(s: &mut Session, f: impl Fn(&mut TextBody)) -> CmdResult {
     let (pos, id) = text_box_target(s).ok_or_else(|| CmdError::Disabled(NO_TEXT_BOX.into()))?;
     let part = s.doc.parts.get_mut(&id).ok_or_else(|| CmdError::Failed("text box vanished".into()))?;
     f(&mut part.body);
@@ -677,9 +698,10 @@ fn bounds(s: &mut Session, v: &Value) -> CmdResult {
 /// position afterwards.
 fn move_object(s: &mut Session, pos: Pos, page: Option<u64>, x: f32, y: f32, (w, h): (f32, f32)) -> Result<Pos, CmdError> {
     use wordcraft_doc::para::Anchor;
-    if pos.story != StoryRef::Body || pos.path.depth() > 0 {
-        return Err(CmdError::Disabled("only objects in the body text can be moved".into()));
+    if pos.path.depth() > 0 || !movable_story(s, pos.story) {
+        return Err(CmdError::Disabled("only objects in the body text, headers and footers can be moved".into()));
     }
+    let story = pos.story;
     let layout = s.layout();
     let cur = layout.object(&pos, s.page_hint).ok_or_else(|| CmdError::Failed("the object isn't laid out".into()))?;
     let page = page.map_or(cur.page, |n| usize::try_from(n).unwrap_or(usize::MAX));
@@ -687,19 +709,19 @@ fn move_object(s: &mut Session, pos: Pos, page: Option<u64>, x: f32, y: f32, (w,
     // Keep a corner of it on the page.
     let x = x.max(12.0 - w).min(pg.w - 12.0);
     let y = y.max(12.0 - h).min(pg.h.min(MAX_OFFSET) - 12.0);
-    let (anchor, on_page) = match anchor_paragraph(&layout, page, y) {
-        Some(path) => (Pos { story: StoryRef::Body, path, off: 0 }, false),
-        None => (nearest_line(&layout, page, y).ok_or_else(|| CmdError::Params("no text on that page to anchor to".into()))?, true),
+    let (anchor, on_page) = match anchor_paragraph(&layout, page, y, story) {
+        Some(path) => (Pos { story, path, off: 0 }, false),
+        None => (nearest_line(&layout, page, y, story).ok_or_else(|| CmdError::Params("no text on that page to anchor to".into()))?, true),
     };
     // Move its character to the anchor (unless it's already in that paragraph).
-    let at = if anchor.path == pos.path && !on_page {
+    let at = if anchor.story == pos.story && anchor.path == pos.path && !on_page {
         pos
     } else {
         let obj = s.doc.para_at(&pos).and_then(|p| p.object_at(pos.off)).cloned().ok_or_else(|| CmdError::Failed("object vanished".into()))?;
         let len = wordcraft_doc::para::OBJ.len_utf8();
         s.doc.delete_range(&pos, &Pos { off: pos.off + len, ..pos.clone() })?;
         let mut at = anchor;
-        if at.path == pos.path && at.off > pos.off {
+        if at.story == pos.story && at.path == pos.path && at.off > pos.off {
             at.off = at.off.saturating_sub(len);
         }
         let at = s.doc.clamp(&at);
@@ -759,37 +781,88 @@ fn unalign(s: &mut Session) -> Result<(), CmdError> {
     Ok(())
 }
 
-/// The top-level body paragraph under `y` on `page`: the last one starting at or above it (else
-/// the first starting on the page).
-pub(crate) fn anchor_paragraph(layout: &wordcraft_layout::DocLayout, page: usize, y: f32) -> Option<wordcraft_doc::Path> {
-    let starts: Vec<(&wordcraft_doc::Path, f32)> = layout
-        .pages
-        .get(page)?
-        .items
-        .iter()
+/// Whether a floating object moves with its text (Word's "Move with Text"): its vertical position
+/// follows its paragraph (as layout places any anchor but the page and its margins), rather than
+/// being fixed on the page ("Fix Position on Page").
+pub fn moves_with_text(f: &Float) -> bool {
+    use wordcraft_doc::para::Anchor;
+    !matches!(f.v_rel, Anchor::Page | Anchor::Margin | Anchor::TopMargin | Anchor::BottomMargin | Anchor::InsideMargin | Anchor::OutsideMargin)
+}
+
+/// Arrange › Wrap Text › Move with Text / Fix Position on Page: anchor the selected floating
+/// object's vertical position to its paragraph or to the page, keeping it where it is now.
+fn move_with_text(s: &mut Session, with_text: bool) -> CmdResult {
+    use wordcraft_doc::para::Anchor;
+    let (pos, obj) = selected(s).ok_or_else(|| CmdError::Disabled("no picture or shape selected".into()))?;
+    let Some((_, _, float)) = obj.frame() else { return Err(CmdError::Disabled("select a floating picture or shape first".into())) };
+    if moves_with_text(float) == with_text {
+        return Ok(json!({"object": serde_json::to_value(&obj).unwrap_or(Value::Null)}));
+    }
+    let hit = s.layout().object(&pos, s.page_hint).ok_or_else(|| CmdError::Failed("the object isn't laid out".into()))?;
+    // Paragraph offsets start at the paragraph's top (the hit's origin), page offsets at the page's.
+    let y = if with_text { hit.rect.y - hit.origin.y } else { hit.rect.y };
+    let o = edit_float(s, &pos, |f| {
+        f.v_rel = if with_text { Anchor::Paragraph } else { Anchor::Page };
+        f.v_align = None;
+        f.y = y.clamp(-MAX_OFFSET, MAX_OFFSET);
+    })?;
+    Ok(json!({"object": serde_json::to_value(o).unwrap_or(Value::Null)}))
+}
+
+/// The top-level paragraph of `story` under `y` on `page`: the last one starting at or above
+/// it (else the first starting on the page). Body paragraphs come from the page's items;
+/// header/footer ones from its header and footer.
+pub(crate) fn anchor_paragraph(layout: &wordcraft_layout::DocLayout, page: usize, y: f32, story: StoryRef) -> Option<wordcraft_doc::Path> {
+    let pg = layout.pages.get(page)?;
+    let items: Box<dyn Iterator<Item = &wordcraft_layout::Placed> + '_> = match story {
+        StoryRef::Body => Box::new(pg.items.iter()),
+        StoryRef::Part(_) => Box::new(pg.header.iter().chain(pg.footer.iter())),
+    };
+    let starts: Vec<(&wordcraft_doc::Path, f32)> = items
         .filter_map(|it| match it {
-            wordcraft_layout::Placed::Lines { story: StoryRef::Body, path, l0: 0, y: top, .. } if path.depth() == 0 => Some((path, *top)),
+            wordcraft_layout::Placed::Lines { story: s, path, l0: 0, y: top, .. } if *s == story && path.depth() == 0 => Some((path, *top)),
             _ => None,
         })
         .collect();
     starts.iter().rev().find(|(_, top)| *top <= y + 0.5).or(starts.first()).map(|(p, _)| (*p).clone())
 }
 
-/// The start of the top-level body line on `page` nearest to `y`.
-pub(crate) fn nearest_line(layout: &wordcraft_layout::DocLayout, page: usize, y: f32) -> Option<Pos> {
-    let lines = wordcraft_layout::hit::page_lines(layout.pages.get(page)?, StoryRef::Body);
+/// The start of the top-level line of `story` on `page` nearest to `y`.
+pub(crate) fn nearest_line(layout: &wordcraft_layout::DocLayout, page: usize, y: f32, story: StoryRef) -> Option<Pos> {
+    let lines = wordcraft_layout::hit::page_lines(layout.pages.get(page)?, story);
     let best = lines.iter().filter(|l| l.path.depth() == 0).min_by(|a, b| {
         let d = |l: &wordcraft_layout::hit::LineHit| if y < l.top { l.top - y } else { (y - l.bottom).max(0.0) };
         d(a).total_cmp(&d(b))
     })?;
     let off = best.para.lines.get(best.li)?.start;
-    Some(Pos { story: StoryRef::Body, path: best.path.clone(), off })
+    Some(Pos { story, path: best.path.clone(), off })
 }
 
 fn obj_size(o: &InlineObject) -> (f32, f32) {
     o.frame().map_or((0.0, 0.0), |(w, h, _)| (w, h))
 }
 
+/// Alt Text: the selected object's description, title and decorative mark, in one undo step.
+fn alt_text(s: &mut Session, v: &Value) -> CmdResult {
+    let (text, title, decorative) = (p::str(v, "text"), p::str(v, "title"), p::bool(v, "decorative"));
+    if text.is_none() && title.is_none() && decorative.is_none() {
+        return Err(CmdError::Params("`text`, `title` or `decorative` is required".into()));
+    }
+    with_obj(s, |o| {
+        if let Some(t) = text {
+            o.set_alt_text(t);
+        }
+        if let Some(f) = o.float_mut() {
+            if let Some(t) = title {
+                f.alt.title = wordcraft_doc::para::cap_alt(t);
+            }
+            if let Some(d) = decorative {
+                f.alt.decorative = d;
+            }
+        }
+    })
+}
+
 fn with_obj(s: &mut Session, f: impl Fn(&mut InlineObject)) -> CmdResult {
     let (pos, _) = selected(s).ok_or_else(|| CmdError::Disabled("no picture or shape selected".into()))?;
     let o = edit_obj(s, &pos, f)?;
@@ -856,8 +929,14 @@ fn size(s: &mut Session, v: &Value) -> CmdResult {
         _ => {}
     }
     let (w, h) = (w.clamp(1.0, 4000.0), h.clamp(1.0, 4000.0));
-    // Any drawing: a group's members scale with its frame (its child space is kept).
-    with_obj(s, |o| o.set_size(w, h))
+    // Any drawing: a group's members scale with its frame (its child space is kept); a chart or
+    // SmartArt graphic lays itself out again at the new size.
+    let theme = s.doc.settings.theme_colors.clone();
+    with_obj(s, |o| {
+        o.set_size(w, h);
+        super::chart::redraw(o, &theme);
+        super::smart_art::redraw(o, &theme);
+    })
 }
 
 /// Apply an image operation to the selected picture's bitmap (stored as a new PNG).
@@ -1037,7 +1116,7 @@ fn object_ref(s: &Session, v: &Value) -> Result<Pos, CmdError> {
         Some(n) => all_objects(s).into_iter().nth(usize::try_from(n).unwrap_or(usize::MAX)).map(|(p, _)| p),
         None => super::parse_pos(v),
     };
-    pos.filter(|p| p.story == StoryRef::Body && s.doc.para_at(p).and_then(|q| q.object_at(p.off)).is_some_and(InlineObject::is_drawing))
+    pos.filter(|p| movable_story(s, p.story) && s.doc.para_at(p).and_then(|q| q.object_at(p.off)).is_some_and(InlineObject::is_drawing))
         .ok_or_else(|| CmdError::Params("no picture or shape there".into()))
 }
 
@@ -1089,9 +1168,13 @@ fn group(s: &mut Session, _: &Value) -> CmdResult {
     picks.sort();
     let layout = s.layout();
     let mut found = Vec::new();
+    let story = picks.first().cloned().map(|p| p.story).ok_or_else(|| CmdError::Failed("nothing to group".into()))?;
+    if picks.iter().any(|p| p.story != story) {
+        return Err(CmdError::Disabled("objects in different stories (body, header, footer) can't be grouped".into()));
+    }
     for pos in &picks {
-        if pos.story != StoryRef::Body || pos.path.depth() > 0 {
-            return Err(CmdError::Disabled("only objects in the body text (not in tables) can be grouped".into()));
+        if pos.path.depth() > 0 || !movable_story(s, pos.story) {
+            return Err(CmdError::Disabled("only objects in the body text, headers and footers (not in tables) can be grouped".into()));
         }
         let obj = s.doc.para_at(pos).and_then(|p| p.object_at(pos.off)).cloned().ok_or_else(|| CmdError::Failed("object vanished".into()))?;
         if matches!(obj, InlineObject::Graphic { .. }) {
@@ -1138,13 +1221,16 @@ fn group(s: &mut Session, _: &Value) -> CmdResult {
             let mut obj = obj.clone();
             obj.set_size(cw, ch);
             if let Some(f) = obj.float_mut() {
-                *f = Float::default();
+                // Each member keeps its own alt text.
+                let alt = std::mem::take(&mut f.alt);
+                *f = Float { alt, ..Float::default() };
                 f.set_spin(spin);
             }
             GroupChild { x: x - x0, y: y - y0, obj }
         })
         .collect();
-    let mut float = found.first().and_then(|(o, _)| o.frame()).map(|(_, _, f)| f.clone()).unwrap_or_default();
+    // The group takes the first member's placement; its members keep their own alt text.
+    let mut float = found.first().and_then(|(o, _)| o.frame()).map(|(_, _, f)| Float { alt: Default::default(), ..f.clone() }).unwrap_or_default();
     float.set_spin(Spin::default());
     let grouped = InlineObject::Group { w, h, float, ch_w: w, ch_h: h, children, canvas: None };
     // Take the members out, last first so the earlier positions hold, and put the group where
@@ -1172,8 +1258,8 @@ fn ungroup(s: &mut Session, _: &Value) -> CmdResult {
     let InlineObject::Group { w, h, float, .. } = &obj else { return Err(CmdError::Disabled("select a group first".into())) };
     // Its offsets, explicit: the members are placed from the same anchor.
     let pos = if float.wrap == Wrap::Inline {
-        if pos.story != StoryRef::Body || pos.path.depth() > 0 {
-            return Err(CmdError::Disabled("only groups in the body text can be ungrouped in line with text".into()));
+        if pos.path.depth() > 0 || !movable_story(s, pos.story) {
+            return Err(CmdError::Disabled("only groups in the body text, headers and footers can be ungrouped in line with text".into()));
         }
         let hit = s.layout().object(&pos, s.page_hint).ok_or_else(|| CmdError::Failed("the object isn't laid out".into()))?;
         move_object(s, pos, Some(hit.page as u64), hit.rect.x, hit.rect.y, (*w, *h))?
@@ -1195,7 +1281,9 @@ fn ungroup(s: &mut Session, _: &Value) -> CmdResult {
             // Grown to its smallest size about its centre, so it stays centred where it was.
             let (x, y) = (x - (mw - cw) / 2.0, y - (mh - ch) / 2.0);
             if let Some(f) = c.float_mut() {
-                *f = Float { x: (float.x + x).clamp(-MAX_OFFSET, MAX_OFFSET), y: (float.y + y).clamp(-MAX_OFFSET, MAX_OFFSET), ..float.clone() };
+                // Each member keeps its own alt text; the group's placement is shared out.
+                let alt = std::mem::take(&mut f.alt);
+                *f = Float { x: (float.x + x).clamp(-MAX_OFFSET, MAX_OFFSET), y: (float.y + y).clamp(-MAX_OFFSET, MAX_OFFSET), alt, ..float.clone() };
                 f.set_spin(spin);
             }
             c
@@ -1371,6 +1459,35 @@ mod tests {
         assert!(s.run("picture.crop", &json!({"left": 0.1})).is_err());
     }
 
+    /// #513: Wrap Text › Fix Position on Page / Move with Text re-anchor a floating picture
+    /// vertically without moving it; one undo step each; an inline picture can't.
+    #[test]
+    fn move_with_text_and_fix_position_keep_the_picture_in_place() {
+        use wordcraft_doc::para::Anchor;
+        let mut s = Session::new(wordcraft_doc::Document::new());
+        s.run("text.insert", &json!({"text": "First paragraph\nSecond"})).unwrap();
+        let data = super::super::insert::base64_encode(&png(20, 10));
+        s.run("insert.picture", &json!({"data": data, "width": 100})).unwrap();
+        assert!(s.run("arrange.moveWithText", &json!({"value": false})).is_err(), "inline: no anchoring");
+        s.run("arrange.wrap", &json!({"wrap": "square"})).unwrap();
+        let v_rel = |s: &Session| selected(s).unwrap().1.frame().unwrap().2.v_rel;
+        let with_text = |s: &Session| moves_with_text(selected(s).unwrap().1.frame().unwrap().2);
+        let rect = |s: &mut Session| {
+            let pos = selected(s).unwrap().0;
+            s.layout().object(&pos, 0).unwrap().rect
+        };
+        let before = rect(&mut s);
+        s.run("arrange.moveWithText", &json!({"value": false})).unwrap();
+        assert_eq!(v_rel(&s), Anchor::Page);
+        assert!(!with_text(&s));
+        assert!((rect(&mut s).y - before.y).abs() < 0.01, "it stays put");
+        s.run("arrange.moveWithText", &json!({"value": true})).unwrap();
+        assert!(with_text(&s));
+        assert!((rect(&mut s).y - before.y).abs() < 0.01, "it stays put");
+        s.run("edit.undo", &json!({})).unwrap();
+        assert_eq!(v_rel(&s), Anchor::Page);
+    }
+
     /// #332: Rotate and Flip turn the frame (an angle and mirroring), never the pixels; an exact
     /// angle is normalised; each is one undo step; the rotated frame takes its rotated room.
     #[test]
@@ -1598,6 +1715,34 @@ mod tests {
         assert_eq!(crop, [0.1, 0.2, 0.05, 0.0]);
     }
 
+    /// A header picture resizes and drags like a body one: the move stays in the header story
+    /// and lands where dropped; the header hit test finds it.
+    #[test]
+    fn header_pictures_can_be_resized_and_dragged() {
+        let mut s = Session::new(wordcraft_doc::Document::new());
+        s.run("insert.editHeader", &json!({})).unwrap();
+        let story = s.sel.focus.story;
+        assert!(matches!(story, StoryRef::Part(_)), "editing the header, got {story:?}");
+        let data = super::super::insert::base64_encode(&png(20, 10));
+        s.run("insert.picture", &json!({"data": data, "width": 100})).unwrap();
+        let (pos, _) = selected(&s).expect("a new header picture is selected");
+        assert_eq!(pos.story, story);
+        s.run("arrange.bounds", &json!({"width": 160, "height": 90})).unwrap();
+        let r = s.run("arrange.bounds", &json!({"page": 0, "x": 200, "y": 60})).unwrap();
+        assert_eq!(r["object"]["float"]["wrap"], "square");
+        let o = s.layout().object(&selected(&s).unwrap().0, 0).expect("laid out");
+        assert_eq!(o.story, story);
+        assert!((o.rect.x - 200.0).abs() < 1.0 && (o.rect.y - 60.0).abs() < 1.0, "{:?}", o.rect);
+        let hit = s.layout().object_at_in(o.page, o.rect.x + 5.0, o.rect.y + 5.0, 4.0, story).expect("header hit");
+        assert_eq!(hit.pos(), o.pos());
+        s.run("arrange.nudge", &json!({"dx": 6, "dy": 4})).unwrap();
+        let n = s.layout().object(&selected(&s).unwrap().0, 0).expect("laid out");
+        assert!((n.rect.x - 206.0).abs() < 1.0 && (n.rect.y - 64.0).abs() < 1.0, "{:?}", n.rect);
+        s.run("edit.undo", &json!({})).unwrap();
+        let u = s.layout().object(&selected(&s).unwrap().0, 0).expect("laid out");
+        assert!((u.rect.x - 200.0).abs() < 1.0 && (u.rect.y - 60.0).abs() < 1.0, "{:?}", u.rect);
+    }
+
     /// Shape Format › Text (#369): direction and alignment on the box the caret is in, then
     /// Create Link to an empty box and Break Link, each one undo step.
     #[test]
@@ -1638,4 +1783,38 @@ mod tests {
         s.run("edit.undo", &json!({})).unwrap();
         assert!(s.doc.text_box_chains().is_empty());
     }
+
+    #[test]
+    fn shape_alt_text_and_decorative_are_one_undo_step_each() {
+        let mut s = Session::new(wordcraft_doc::Document::new());
+        s.run("insert.shape", &json!({"kind": "ellipse"})).unwrap();
+        s.run("object.altText", &json!({"text": "A green circle", "title": "Logo"})).unwrap();
+        let (_, o) = selected(&s).unwrap();
+        assert_eq!((o.alt_text(), o.frame().map(|f| f.2.alt.title.as_str()), o.is_decorative()), ("A green circle", Some("Logo"), false));
+        s.run("object.altText", &json!({"decorative": true})).unwrap();
+        assert!(selected(&s).unwrap().1.is_decorative());
+        s.run("edit.undo", &json!({})).unwrap();
+        let (_, o) = selected(&s).unwrap();
+        assert!(!o.is_decorative() && o.alt_text() == "A green circle");
+        s.run("edit.undo", &json!({})).unwrap();
+        assert_eq!(selected(&s).unwrap().1.alt_text(), "");
+        // Hostile input is capped, and nothing to set is an error.
+        s.run("object.altText", &json!({"text": "x".repeat(50_000)})).unwrap();
+        assert_eq!(selected(&s).unwrap().1.alt_text().len(), wordcraft_doc::para::MAX_ALT_TEXT);
+        assert!(s.run("object.altText", &json!({})).is_err());
+        // A picture-only alias stays a picture-only alias.
+        assert!(s.run("picture.altText", &json!({"text": "no"})).is_err());
+    }
+
+    #[test]
+    fn table_alt_text_sets_title_and_description() {
+        let mut s = Session::new(wordcraft_doc::Document::new());
+        s.run("insert.table", &json!({"rows": 2, "cols": 2})).unwrap();
+        s.run("table.altText", &json!({"title": "Prices", "text": "Prices by year"})).unwrap();
+        let t = s.doc.body.iter().find_map(|b| if let wordcraft_doc::Block::Table(t) = &**b { Some(t.clone()) } else { None }).unwrap();
+        assert_eq!((t.props.caption.as_deref(), t.props.description.as_deref()), (Some("Prices"), Some("Prices by year")));
+        s.run("table.altText", &json!({"text": ""})).unwrap();
+        let t = s.doc.body.iter().find_map(|b| if let wordcraft_doc::Block::Table(t) = &**b { Some(t.clone()) } else { None }).unwrap();
+        assert_eq!((t.props.caption.as_deref(), t.props.description.as_deref()), (Some("Prices"), None));
+    }
 }
diff --git a/crates/engine/src/cmd/options.rs b/crates/engine/src/cmd/options.rs
new file mode 100644
index 0000000000..c7a8a49c57
--- /dev/null
+++ b/crates/engine/src/cmd/options.rs
@@ -0,0 +1,188 @@
+//! File › Options (#485): the settings agents can read and change without the window — user
+//! name and initials, typing (replace selection, overtype), measurement units, formatting marks
+//! and proofing. The Options page in the app sets them through the same command.
+
+use serde_json::{Value, json};
+
+use crate::{CmdError, CmdResult, CommandSpec, Prefs, Session, p};
+
+/// Options panes, in the order the page lists them (the `pane` param of `file.options`).
+pub const PANES: [&str; 8] = ["general", "display", "proofing", "save", "language", "accessibility", "advanced", "agents"];
+
+/// Longest initials kept, in characters.
+pub const MAX_INITIALS_CHARS: usize = 9;
+/// Longest word the custom dictionary takes, in characters.
+pub const MAX_WORD_CHARS: usize = 64;
+/// Most words one call may add or remove.
+const MAX_WORDS_PER_CALL: usize = 1000;
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec::new("file.options", "Options", "File", options)
+            .params(
+                r#"{"pane"?: "general|display|proofing|save|language|accessibility|advanced|agents", "author"?: string, "initials"?: string, "units"?: "inches|centimeters|millimeters|points|picas", "typingReplacesSelection"?: bool, "insertKeyOvertype"?: bool, "overtype"?: bool, "marks"?: {"tabs"?: bool, "spaces"?: bool, "paragraphs"?: bool, "hidden"?: bool}, "checkSpelling"?: bool, "markGrammar"?: bool, "ignoreUppercase"?: bool, "ignoreNumbers"?: bool, "ignoreInternet"?: bool, "addWords"?: [string], "removeWords"?: [string]} — with any setting it changes them and opens nothing; without, it opens File › Options (at `pane`). Returns the settings."#,
+            )
+            .pure(),
+        CommandSpec::new("text.overtype", "Overtype", "File › Options › Advanced", |s, v| {
+            s.prefs.overtype = p::bool(v, "value").unwrap_or(!s.prefs.overtype);
+            Ok(json!({"value": s.prefs.overtype}))
+        })
+        .params(r#"{"value"?: bool (default: toggle)}"#)
+        .pure(),
+    ]
+}
+
+/// The on/off settings by their `file.options` name.
+fn flags() -> [(&'static str, fn(&mut Prefs) -> &mut bool); 7] {
+    [
+        ("typingReplacesSelection", |p| &mut p.typing_replaces_selection),
+        ("insertKeyOvertype", |p| &mut p.insert_key_overtype),
+        ("overtype", |p| &mut p.overtype),
+        ("markGrammar", |p| &mut p.mark_grammar),
+        ("ignoreUppercase", |p| &mut p.ignore_uppercase),
+        ("ignoreNumbers", |p| &mut p.ignore_numbers),
+        ("ignoreInternet", |p| &mut p.ignore_internet),
+    ]
+}
+
+fn mark_flags() -> [(&'static str, fn(&mut wordcraft_layout::display::FormattingMarks) -> &mut bool); 4] {
+    [("tabs", |m| &mut m.tabs), ("spaces", |m| &mut m.spaces), ("paragraphs", |m| &mut m.paragraphs), ("hidden", |m| &mut m.hidden)]
+}
+
+fn bool_param(v: &Value, k: &str) -> Result<Option<bool>, CmdError> {
+    match v.get(k) {
+        None | Some(Value::Null) => Ok(None),
+        Some(Value::Bool(b)) => Ok(Some(*b)),
+        Some(_) => Err(CmdError::Params(format!("`{k}` must be true or false"))),
+    }
+}
+
+/// Words for the custom dictionary: trimmed, single words, at most [`MAX_WORD_CHARS`] long.
+fn words_param(v: &Value, k: &str) -> Result<Vec<String>, CmdError> {
+    let Some(x) = v.get(k).filter(|x| !x.is_null()) else { return Ok(Vec::new()) };
+    let bad = || CmdError::Params(format!("`{k}` must be a list of words"));
+    let list = x.as_array().ok_or_else(bad)?;
+    if list.len() > MAX_WORDS_PER_CALL {
+        return Err(CmdError::Params(format!("`{k}` takes at most {MAX_WORDS_PER_CALL} words")));
+    }
+    let mut out = Vec::new();
+    for w in list {
+        let w = w.as_str().ok_or_else(bad)?.trim();
+        if w.is_empty() || w.chars().count() > MAX_WORD_CHARS || w.chars().any(|c| c.is_whitespace() || c.is_control()) {
+            return Err(CmdError::Params(format!("`{k}`: {w:?} isn't a single word of at most {MAX_WORD_CHARS} characters")));
+        }
+        out.push(w.to_string());
+    }
+    Ok(out)
+}
+
+fn options(s: &mut Session, v: &Value) -> CmdResult {
+    let pane = match p::str(v, "pane") {
+        Some(name) if PANES.contains(&name) => name,
+        Some(name) => return Err(CmdError::Params(format!("unknown pane `{name}`; one of {}", PANES.join(", ")))),
+        None => "general",
+    };
+    // Read every setting first, so a bad one changes nothing.
+    let author = match v.get("author") {
+        None | Some(Value::Null) => None,
+        Some(Value::String(n)) => Some(n.clone()),
+        Some(_) => return Err(CmdError::Params("`author` must be a string".into())),
+    };
+    let initials = match v.get("initials") {
+        None | Some(Value::Null) => None,
+        Some(Value::String(i)) => Some(i.trim().chars().filter(|c| !c.is_control()).take(MAX_INITIALS_CHARS).collect::<String>()),
+        Some(_) => return Err(CmdError::Params("`initials` must be a string".into())),
+    };
+    let units = match v.get("units") {
+        None | Some(Value::Null) => None,
+        Some(u) => Some(
+            serde_json::from_value::<wordcraft_geom::Unit>(u.clone())
+                .map_err(|_| CmdError::Params("`units` is one of inches, centimeters, millimeters, points, picas".into()))?,
+        ),
+    };
+    let mut flag_values = Vec::new();
+    for (k, f) in flags() {
+        if let Some(b) = bool_param(v, k)? {
+            flag_values.push((f, b));
+        }
+    }
+    let mut mark_values = Vec::new();
+    match v.get("marks") {
+        None | Some(Value::Null) => {}
+        Some(m @ Value::Object(_)) => {
+            for (k, f) in mark_flags() {
+                if let Some(b) = bool_param(m, k)? {
+                    mark_values.push((f, b));
+                }
+            }
+        }
+        Some(_) => return Err(CmdError::Params("`marks` must be an object of true/false".into())),
+    }
+    let check_spelling = bool_param(v, "checkSpelling")?;
+    let add = words_param(v, "addWords")?;
+    let remove = words_param(v, "removeWords")?;
+
+    let setting = author.is_some()
+        || initials.is_some()
+        || units.is_some()
+        || !flag_values.is_empty()
+        || !mark_values.is_empty()
+        || check_spelling.is_some()
+        || !add.is_empty()
+        || !remove.is_empty();
+    if let Some(name) = author {
+        super::file::set_author(s, &json!({"name": name}))?;
+    }
+    if let Some(i) = initials {
+        s.initials = i;
+    }
+    if let Some(u) = units {
+        s.prefs.units = u;
+    }
+    for (f, b) in flag_values {
+        *f(&mut s.prefs) = b;
+    }
+    for (f, b) in mark_values {
+        *f(&mut s.prefs.marks) = b;
+    }
+    if let Some(b) = check_spelling {
+        s.view.proofing = b;
+    }
+    for w in &add {
+        wordcraft_proof::add_word(w);
+    }
+    for w in &remove {
+        wordcraft_proof::remove_word(w);
+    }
+    if setting {
+        // Marks, hidden text and proofing change what is laid out.
+        s.relayout();
+    } else {
+        s.ui_requests.push(json!({"open": "options", "pane": pane}));
+    }
+    let mut r = current(s);
+    if let Some(o) = r.as_object_mut() {
+        o.insert("opened".into(), json!(!setting));
+    }
+    Ok(r)
+}
+
+/// The settings `file.options` reads and sets.
+pub fn current(s: &Session) -> Value {
+    let pr = &s.prefs;
+    json!({
+        "author": s.author,
+        "initials": s.user_initials(),
+        "units": pr.units,
+        "typingReplacesSelection": pr.typing_replaces_selection,
+        "insertKeyOvertype": pr.insert_key_overtype,
+        "overtype": pr.overtype,
+        "marks": pr.marks,
+        "checkSpelling": s.view.proofing,
+        "markGrammar": pr.mark_grammar,
+        "ignoreUppercase": pr.ignore_uppercase,
+        "ignoreNumbers": pr.ignore_numbers,
+        "ignoreInternet": pr.ignore_internet,
+        "dictionary": wordcraft_proof::user_dictionary(),
+    })
+}
diff --git a/crates/engine/src/cmd/outline.rs b/crates/engine/src/cmd/outline.rs
new file mode 100644
index 0000000000..21dcecb133
--- /dev/null
+++ b/crates/engine/src/cmd/outline.rs
@@ -0,0 +1,509 @@
+//! Outline view and the Outlining tab: outline levels (Heading 1–9 or body text), promote and
+//! demote, moving paragraphs with what is under them, expand and collapse, Show Level, Show First
+//! Line Only, Show Text Formatting. What's collapsed and shown is view state ([`OutlineState`]),
+//! never saved in the document; level changes and moves are ordinary undoable edits.
+
+use std::collections::BTreeSet;
+use std::hash::{Hash, Hasher};
+
+use serde::{Deserialize, Serialize};
+use serde_json::{Value, json};
+use wordcraft_doc::{Block, Document, Pos, StoryRef};
+use wordcraft_layout::ViewMode;
+use wordcraft_layout::outline::{self as ol, BODY, OutlineView};
+
+use super::sel_result;
+use crate::{CmdError, CmdResult, CommandSpec, Selection, Session, p};
+
+/// What Outline view shows (part of [`crate::ViewState`]).
+#[derive(Clone, Debug, Default, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct OutlineState {
+    /// Collapsed headings: body block index and a hash of the heading's text, so they are found
+    /// again after edits move them (see [`after_command`]).
+    pub collapsed: Vec<(usize, u64)>,
+    /// Show Level: 1–9, or 0 for all levels.
+    pub show_level: u8,
+    /// Show First Line Only (body text).
+    pub first_line_only: bool,
+    /// Show Text Formatting turned off.
+    pub hide_formatting: bool,
+}
+
+impl OutlineState {
+    /// What the layout needs.
+    pub fn view(&self) -> OutlineView {
+        OutlineView {
+            collapsed: self.collapsed.iter().map(|(i, _)| *i).collect(),
+            show_level: self.show_level,
+            first_line_only: self.first_line_only,
+            plain: self.hide_formatting,
+        }
+    }
+}
+
+fn in_outline(s: &Session) -> Option<&'static str> {
+    (s.view.mode != ViewMode::Outline).then_some("only in Outline view")
+}
+
+const LEVEL: &str = r#"{"level": 1-9 | "body"}"#;
+const BLOCK: &str = r#"{"block"?: body paragraph index (default: the selection)}"#;
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec::new("outline.promoteToHeading1", "Promote to Heading 1", "Outlining › Outline Tools", |s, _| set_levels(s, Some(1))),
+        CommandSpec::new("outline.promote", "Promote", "Outlining › Outline Tools", |s, _| s.run("para.promote", &json!({}))),
+        CommandSpec::new("outline.demote", "Demote", "Outlining › Outline Tools", |s, _| s.run("para.demote", &json!({}))),
+        CommandSpec::new("outline.demoteToBody", "Demote to Body Text", "Outlining › Outline Tools", |s, _| set_levels(s, None)),
+        CommandSpec::new("outline.level", "Outline Level", "Outlining › Outline Tools", |s, v| {
+            let level = match v.get("level") {
+                Some(Value::String(b)) if b.eq_ignore_ascii_case("body") => None,
+                Some(x) => match x.as_u64() {
+                    Some(n @ 1..=9) => Some(n as u8),
+                    _ => return Err(CmdError::Params(format!("`level` must be 1–9 or \"body\": {LEVEL}"))),
+                },
+                None => return Err(CmdError::Params(format!("`level` is required: {LEVEL}"))),
+            };
+            set_levels(s, level)
+        })
+        .params(LEVEL),
+        CommandSpec::new("outline.moveUp", "Move Up", "Outlining › Outline Tools", |s, _| s.run("para.moveUp", &json!({}))),
+        CommandSpec::new("outline.moveDown", "Move Down", "Outlining › Outline Tools", |s, _| s.run("para.moveDown", &json!({}))),
+        CommandSpec::new("outline.expand", "Expand", "Outlining › Outline Tools", |s, v| expand(s, v, false))
+            .key("Alt+Shift+=")
+            .params(BLOCK)
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.collapse", "Collapse", "Outlining › Outline Tools", |s, v| collapse(s, v, false))
+            .key("Alt+Shift+-")
+            .params(BLOCK)
+            .when(in_outline)
+            .pure(),
+        // Double-clicking a heading's symbol: all of it collapsed, or all of it expanded.
+        CommandSpec::new("outline.toggle", "Expand or Collapse Heading", "Outlining › Outline Tools", |s, v| {
+            let collapsed = targets(s, v).first().is_some_and(|h| s.view.outline.collapsed.iter().any(|(i, _)| i == h));
+            if collapsed { expand(s, v, true) } else { collapse(s, v, true) }
+        })
+        .params(BLOCK)
+        .when(in_outline)
+        .pure(),
+        // Clicking a symbol: the paragraph and everything under it.
+        CommandSpec::new("outline.selectSubtree", "Select Heading and Content", "Outlining › Outline Tools", select_subtree)
+            .params(BLOCK)
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.showLevel", "Show Level", "Outlining › Outline Tools", |s, v| {
+            let level = match v.get("level") {
+                Some(Value::String(a)) if a.eq_ignore_ascii_case("all") => 0,
+                Some(x) => match x.as_u64() {
+                    Some(n @ 1..=9) => n as u8,
+                    _ => return Err(CmdError::Params(r#"`level` must be 1–9 or "all""#.into())),
+                },
+                None => return Err(CmdError::Params(r#"`level` is required: 1–9 or "all""#.into())),
+            };
+            show_level(s, level)
+        })
+        .params(r#"{"level": 1-9 | "all"}"#)
+        .when(in_outline)
+        .pure(),
+        CommandSpec::new("outline.showLevel1", "Show Level 1", "Outlining › Outline Tools", |s, _| show_level(s, 1))
+            .key("Alt+Shift+1")
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.showLevel2", "Show Level 2", "Outlining › Outline Tools", |s, _| show_level(s, 2))
+            .key("Alt+Shift+2")
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.showLevel3", "Show Level 3", "Outlining › Outline Tools", |s, _| show_level(s, 3))
+            .key("Alt+Shift+3")
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.showLevel4", "Show Level 4", "Outlining › Outline Tools", |s, _| show_level(s, 4))
+            .key("Alt+Shift+4")
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.showLevel5", "Show Level 5", "Outlining › Outline Tools", |s, _| show_level(s, 5))
+            .key("Alt+Shift+5")
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.showLevel6", "Show Level 6", "Outlining › Outline Tools", |s, _| show_level(s, 6))
+            .key("Alt+Shift+6")
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.showLevel7", "Show Level 7", "Outlining › Outline Tools", |s, _| show_level(s, 7))
+            .key("Alt+Shift+7")
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.showLevel8", "Show Level 8", "Outlining › Outline Tools", |s, _| show_level(s, 8))
+            .key("Alt+Shift+8")
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.showLevel9", "Show Level 9", "Outlining › Outline Tools", |s, _| show_level(s, 9))
+            .key("Alt+Shift+9")
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.showAll", "Show All Levels", "Outlining › Outline Tools", |s, _| show_level(s, 0))
+            .key("Alt+Shift+A")
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.firstLineOnly", "Show First Line Only", "Outlining › Outline Tools", |s, v| {
+            s.view.outline.first_line_only = p::bool(v, "value").unwrap_or(!s.view.outline.first_line_only);
+            Ok(json!({"value": s.view.outline.first_line_only}))
+        })
+        .params(r#"{"value"?: bool}"#)
+        .when(in_outline)
+        .pure(),
+        CommandSpec::new("outline.showFormatting", "Show Text Formatting", "Outlining › Outline Tools", |s, v| {
+            let on = p::bool(v, "value").unwrap_or(s.view.outline.hide_formatting);
+            s.view.outline.hide_formatting = !on;
+            Ok(json!({"value": on}))
+        })
+        .params(r#"{"value"?: bool}"#)
+        .when(in_outline)
+        .pure(),
+        CommandSpec::new("outline.close", "Close Outline View", "Outlining › Close", |s, _| s.run("view.printLayout", &json!({})))
+            .when(in_outline)
+            .pure(),
+        CommandSpec::new("outline.state", "Outline State", "Outlining", |s, _| {
+            let levels = ol::levels(&s.doc);
+            let hidden = ol::hidden(&levels, &s.view.outline.view());
+            let shown: Vec<usize> = hidden.iter().enumerate().filter(|(_, h)| !**h).map(|(i, _)| i).collect();
+            Ok(json!({
+                "levels": levels,
+                "shown": shown,
+                "collapsed": s.view.outline.view().collapsed,
+                "showLevel": s.view.outline.show_level,
+                "firstLineOnly": s.view.outline.first_line_only,
+                "showFormatting": !s.view.outline.hide_formatting,
+            }))
+        })
+        .pure(),
+    ]
+}
+
+/// The top-level body blocks the selection touches (none outside the body text or in a table).
+fn selected_blocks(s: &Session) -> Option<(usize, usize)> {
+    let (a, b) = s.sel.ordered();
+    if a.story != StoryRef::Body || b.story != StoryRef::Body {
+        return None;
+    }
+    let i0 = *a.path.0.first()? as usize;
+    let mut i1 = *b.path.0.first()? as usize;
+    // A selection ending at the very start of a paragraph doesn't touch it.
+    if i1 > i0 && b.off == 0 && b.path.0.len() == 1 {
+        i1 -= 1;
+    }
+    Some((i0, i1))
+}
+
+/// The headings a command acts on: `block` when given, else the selected headings, else the
+/// heading the caret is under.
+fn targets(s: &Session, v: &Value) -> Vec<usize> {
+    let levels = ol::levels(&s.doc);
+    let heading = |i: usize| levels.get(i).is_some_and(|l| *l < BODY);
+    if let Some(b) = v.get("block").and_then(Value::as_u64) {
+        let b = usize::try_from(b).unwrap_or(usize::MAX);
+        return if heading(b) { vec![b] } else { Vec::new() };
+    }
+    let Some((i0, i1)) = selected_blocks(s) else { return Vec::new() };
+    let sel: Vec<usize> = (i0..=i1.min(levels.len().saturating_sub(1))).filter(|i| heading(*i)).collect();
+    if !sel.is_empty() {
+        return sel;
+    }
+    (0..=i0.min(levels.len().saturating_sub(1))).rev().find(|i| heading(*i)).into_iter().collect()
+}
+
+fn text_hash(doc: &Document, i: usize) -> Option<u64> {
+    let Some(Block::Para(p)) = doc.body.get(i).map(|b| &**b) else { return None };
+    let mut h = std::collections::hash_map::DefaultHasher::new();
+    p.text.hash(&mut h);
+    Some(h.finish())
+}
+
+fn set_collapsed(s: &mut Session, set: &BTreeSet<usize>) {
+    s.view.outline.collapsed = set.iter().filter_map(|i| text_hash(&s.doc, *i).map(|h| (*i, h))).collect();
+}
+
+/// Show Level turned into collapsed headings, so single headings can then be expanded or
+/// collapsed: the headings at the shown level with something under them are collapsed and every
+/// level is shown.
+fn settle_show_level(s: &mut Session) -> BTreeSet<usize> {
+    let mut set = s.view.outline.view().collapsed;
+    let n = s.view.outline.show_level;
+    if (1..=9).contains(&n) {
+        let levels = ol::levels(&s.doc);
+        let hidden = ol::hidden(&levels, &s.view.outline.view());
+        for (i, l) in levels.iter().enumerate() {
+            if *l < BODY && *l <= n && !hidden.get(i).copied().unwrap_or(true) && ol::has_children(&levels, i) {
+                // A heading whose next shown paragraph is deeper keeps that open.
+                let deeper_shown = (i + 1..ol::subtree_end(&levels, i)).any(|j| !hidden.get(j).copied().unwrap_or(true));
+                if !deeper_shown {
+                    set.insert(i);
+                }
+            }
+        }
+        s.view.outline.show_level = 0;
+    }
+    set
+}
+
+/// Expand: a collapsed heading opens (what was collapsed under it stays so); an open one shows
+/// the shallowest collapsed level under it. `all`: the heading and everything under it opens.
+fn expand(s: &mut Session, v: &Value, all: bool) -> CmdResult {
+    let targets = targets(s, v);
+    let mut set = settle_show_level(s);
+    let levels = ol::levels(&s.doc);
+    for h in targets {
+        let end = ol::subtree_end(&levels, h);
+        if all {
+            set.retain(|i| *i < h || *i >= end);
+            continue;
+        }
+        if set.remove(&h) {
+            continue;
+        }
+        let hidden = ol::hidden(&levels, &OutlineView { collapsed: set.clone(), ..Default::default() });
+        let open: Vec<usize> = (h + 1..end).filter(|j| set.contains(j) && !hidden.get(*j).copied().unwrap_or(true)).collect();
+        if let Some(top) = open.iter().filter_map(|j| levels.get(*j)).min().copied() {
+            for j in open {
+                if levels.get(j) == Some(&top) {
+                    set.remove(&j);
+                }
+            }
+        }
+    }
+    set_collapsed(s, &set);
+    sel_result(s)
+}
+
+/// Collapse: the deepest open level under a heading closes first; a heading with nothing open
+/// under it closes itself. `all`: the heading closes at once.
+fn collapse(s: &mut Session, v: &Value, all: bool) -> CmdResult {
+    let targets = targets(s, v);
+    let mut set = settle_show_level(s);
+    let levels = ol::levels(&s.doc);
+    for h in targets {
+        if !ol::has_children(&levels, h) || set.contains(&h) {
+            continue;
+        }
+        if all {
+            set.insert(h);
+            continue;
+        }
+        let hidden = ol::hidden(&levels, &OutlineView { collapsed: set.clone(), ..Default::default() });
+        let open: Vec<usize> = (h + 1..ol::subtree_end(&levels, h))
+            .filter(|j| {
+                levels.get(*j).is_some_and(|l| *l < BODY)
+                    && ol::has_children(&levels, *j)
+                    && !set.contains(j)
+                    && !hidden.get(*j).copied().unwrap_or(true)
+            })
+            .collect();
+        match open.iter().filter_map(|j| levels.get(*j)).max().copied() {
+            Some(deepest) => {
+                for j in open {
+                    if levels.get(j) == Some(&deepest) {
+                        set.insert(j);
+                    }
+                }
+            }
+            None => {
+                set.insert(h);
+            }
+        }
+    }
+    set_collapsed(s, &set);
+    sel_result(s)
+}
+
+fn show_level(s: &mut Session, level: u8) -> CmdResult {
+    s.view.outline.show_level = level;
+    s.view.outline.collapsed.clear();
+    Ok(json!({"showLevel": level}))
+}
+
+/// The end of block `i` as a selection end: the end of its text, or for a table the start of what
+/// follows it.
+fn block_end(doc: &Document, i: usize) -> Pos {
+    match doc.body.get(i).map(|b| &**b) {
+        Some(Block::Para(p)) => Pos::body(i, p.text.len()),
+        _ => doc.clamp(&Pos::body(i.saturating_add(1), 0)),
+    }
+}
+
+fn select_subtree(s: &mut Session, v: &Value) -> CmdResult {
+    let levels = ol::levels(&s.doc);
+    let start = match v.get("block").and_then(Value::as_u64) {
+        Some(b) => usize::try_from(b).unwrap_or(usize::MAX),
+        None => selected_blocks(s).map(|(i, _)| i).ok_or_else(|| CmdError::Failed("put the caret in the body text".into()))?,
+    };
+    if start >= levels.len() {
+        return Err(CmdError::Params("`block` is past the end of the document".into()));
+    }
+    let end = ol::subtree_end(&levels, start).max(start + 1);
+    let anchor = s.doc.clamp(&Pos::body(start, 0));
+    let focus = block_end(&s.doc, end - 1);
+    s.sel = Selection { anchor, focus };
+    s.goal_x = None;
+    sel_result(s)
+}
+
+/// Apply Heading `level` (or body text, `None`) to the selected paragraphs.
+fn set_levels(s: &mut Session, level: Option<u8>) -> CmdResult {
+    let (a, b) = s.sel.ordered();
+    let paths = s.doc.paths_between(&a, &b);
+    if paths.is_empty() {
+        return Err(CmdError::Failed("select paragraphs to change their level".into()));
+    }
+    for path in paths {
+        super::para::set_heading(s, a.story, &path, level)?;
+    }
+    sel_result(s)
+}
+
+/// The headings hidden under collapsed headings in the selection, with their levels: promoting
+/// or demoting a collapsed heading carries them along (Outline view only).
+pub(crate) fn hidden_subheadings(s: &Session) -> Vec<(usize, u8)> {
+    if s.view.mode != ViewMode::Outline || s.view.outline.collapsed.is_empty() {
+        return Vec::new();
+    }
+    let Some((i0, i1)) = selected_blocks(s) else { return Vec::new() };
+    let levels = ol::levels(&s.doc);
+    let hidden = ol::hidden(&levels, &s.view.outline.view());
+    let mut out = Vec::new();
+    for &(h, _) in &s.view.outline.collapsed {
+        if h < i0 || h > i1 {
+            continue;
+        }
+        for j in h + 1..ol::subtree_end(&levels, h) {
+            if let Some(&l) = levels.get(j).filter(|l| **l < BODY)
+                && hidden.get(j).copied().unwrap_or(false)
+                && !out.iter().any(|(k, _)| *k == j)
+            {
+                out.push((j, l));
+            }
+        }
+    }
+    out
+}
+
+/// Move Up / Move Down in Outline view: the selected paragraphs and what is hidden under them
+/// pass the next shown paragraph and what is hidden under it. `None` when the selection isn't in
+/// top-level body paragraphs (the ordinary move then applies).
+pub(crate) fn move_shown(s: &mut Session, up: bool) -> Option<CmdResult> {
+    if s.view.mode != ViewMode::Outline {
+        return None;
+    }
+    let (a, b) = s.sel.ordered();
+    if a.story != StoryRef::Body || b.story != StoryRef::Body || a.path.0.len() != 1 || b.path.0.len() != 1 {
+        return None;
+    }
+    let (i0, i1) = selected_blocks(s)?;
+    let levels = ol::levels(&s.doc);
+    let hidden = ol::hidden(&levels, &s.view.outline.view());
+    let is_hidden = |i: usize| hidden.get(i).copied().unwrap_or(false);
+    let mut r1 = i1;
+    while is_hidden(r1 + 1) {
+        r1 += 1;
+    }
+    let len = s.doc.body.len();
+    let (lo, hi, shift): (usize, usize, isize) = if up {
+        let Some(v) = (0..i0).rev().find(|j| !is_hidden(*j)) else { return Some(Err(CmdError::Failed("already at the top".into()))) };
+        (v, r1, -((i0 - v) as isize))
+    } else {
+        let w = r1 + 1;
+        if w >= len {
+            return Some(Err(CmdError::Failed("already at the bottom".into())));
+        }
+        let mut e = w;
+        while is_hidden(e + 1) {
+            e += 1;
+        }
+        (i0, e, (e - r1) as isize)
+    };
+    let blocks = match s.doc.container_mut(StoryRef::Body, &a.path) {
+        Ok(b) => b,
+        Err(e) => return Some(Err(e.into())),
+    };
+    let Some(slice) = blocks.get_mut(lo..=hi) else { return Some(Err(CmdError::Failed("bad range".into()))) };
+    if slice.iter().any(|b| b.as_para().is_some_and(|p| p.section.is_some())) {
+        return Some(Err(CmdError::Failed("paragraphs don't move across a section break".into())));
+    }
+    if up {
+        slice.rotate_left(i0 - lo);
+    } else {
+        slice.rotate_right(hi - r1);
+    }
+    // The selection moves with the paragraphs; an end just past them stays just past them.
+    let new_r1 = r1.saturating_add_signed(shift);
+    let map = |p: &Pos| -> Pos {
+        let i = p.path.last();
+        if (i0..=r1).contains(&i) {
+            Pos { path: p.path.with_last(i.saturating_add_signed(shift)), ..p.clone() }
+        } else if new_r1 + 1 < len {
+            Pos::body(new_r1 + 1, 0)
+        } else {
+            block_end(&s.doc, new_r1)
+        }
+    };
+    let (anchor, focus) = (map(&s.sel.anchor), map(&s.sel.focus));
+    s.sel = Selection { anchor: s.doc.clamp(&anchor), focus: s.doc.clamp(&focus) };
+    s.goal_x = None;
+    Some(sel_result(s))
+}
+
+/// After every command: collapsed headings are found again where edits moved them (by their
+/// text; one whose text changed in place stays collapsed), and in Outline view a caret the
+/// outline doesn't show (in collapsed text, or past a body paragraph's first line) moves on to
+/// the nearest place it does, in the direction it was going.
+pub(crate) fn after_command(s: &mut Session, before: &Selection) {
+    if !s.view.outline.collapsed.is_empty() {
+        let hashes: Vec<Option<u64>> = (0..s.doc.body.len()).map(|i| text_hash(&s.doc, i)).collect();
+        let levels = ol::levels(&s.doc);
+        let mut used = BTreeSet::new();
+        let mut out = Vec::new();
+        for (i, h) in std::mem::take(&mut s.view.outline.collapsed) {
+            let free = |j: usize, used: &BTreeSet<usize>| levels.get(j).is_some_and(|l| *l < BODY) && !used.contains(&j);
+            let same = |j: usize| hashes.get(j).copied().flatten() == Some(h);
+            let found = if free(i, &used) && same(i) {
+                Some(i)
+            } else {
+                (0..levels.len()).filter(|j| free(*j, &used) && same(*j)).min_by_key(|j| j.abs_diff(i)).or_else(|| free(i, &used).then_some(i))
+            };
+            if let Some(j) = found {
+                used.insert(j);
+                out.push((j, hashes.get(j).copied().flatten().unwrap_or(h)));
+            }
+        }
+        out.sort_unstable();
+        s.view.outline.collapsed = out;
+    }
+    if s.view.mode != ViewMode::Outline || !s.sel.is_collapsed() || s.sel.focus.story != StoryRef::Body {
+        return;
+    }
+    if s.layout().caret(&s.sel.focus).is_some() {
+        return;
+    }
+    let Some(&block) = s.sel.focus.path.0.first() else { return };
+    let block = block as usize;
+    let levels = ol::levels(&s.doc);
+    let hidden = ol::hidden(&levels, &s.view.outline.view());
+    let layout = s.layout();
+    let shown_para = |j: usize| !hidden.get(j).copied().unwrap_or(true) && matches!(s.doc.body.get(j).map(|b| &**b), Some(Block::Para(_)));
+    let forward = before.focus <= s.sel.focus;
+    let next = (block + 1..levels.len()).find(|j| shown_para(*j)).map(|j| Pos::body(j, 0));
+    let prev = || {
+        if shown_para(block) {
+            return Some(Pos::body(block, 0));
+        }
+        // The end of the paragraph before, if it shows (not past a first line).
+        let j = (0..block).rev().find(|j| shown_para(*j))?;
+        let end = block_end(&s.doc, j);
+        Some(if layout.caret(&end).is_some() { end } else { Pos::body(j, 0) })
+    };
+    let target = if forward { next.or_else(prev) } else { prev().or(next) };
+    if let Some(t) = target {
+        let t = s.doc.clamp(&t);
+        s.sel = Selection::caret(t);
+    }
+}
diff --git a/crates/engine/src/cmd/page.rs b/crates/engine/src/cmd/page.rs
index f7c3388aed..c98be2a0d1 100644
--- a/crates/engine/src/cmd/page.rs
+++ b/crates/engine/src/cmd/page.rs
@@ -4,7 +4,7 @@ use serde_json::{Value, json};
 use wordcraft_doc::section::{
     Columns, DocGrid, DocGridType, LineNumbering, MAX_CHAR_SPACE, MAX_GRID_PITCH, MIN_GRID_PITCH, SectionProps, SectionStart,
 };
-use wordcraft_doc::{Block, Pos};
+use wordcraft_doc::{Block, Pos, StoryRef};
 
 use super::sel_result;
 use crate::{CmdError, CmdResult, CommandSpec, Selection, Session, p};
@@ -30,23 +30,14 @@ pub fn specs() -> Vec<CommandSpec> {
             ),
         CommandSpec::new("layout.break", "Breaks", "Layout › Page Setup", breaks)
             .params(r#"{"kind": "page|column|textWrapping|nextPage|continuous|evenPage|oddPage"}"#),
-        CommandSpec::new("layout.lineNumbers", "Line Numbers", "Layout › Page Setup", |s, v| {
-            let mode = p::str(v, "value").unwrap_or("continuous");
-            with_sect(s, |x| {
-                x.line_numbers = match mode {
-                    "none" => None,
-                    "restartPage" => Some(LineNumbering { restart: wordcraft_doc::section::LineNumberRestart::Page, ..Default::default() }),
-                    "restartSection" => Some(LineNumbering { restart: wordcraft_doc::section::LineNumberRestart::Section, ..Default::default() }),
-                    _ => Some(LineNumbering { restart: wordcraft_doc::section::LineNumberRestart::Continuous, ..Default::default() }),
-                }
-            })
-        })
-        .params(r#"{"value": "none|continuous|restartPage|restartSection"}"#),
-        CommandSpec::new("layout.hyphenation", "Hyphenation", "Layout › Page Setup", |s, v| {
-            let on = p::bool(v, "value").unwrap_or(!s.doc.settings.auto_hyphenation);
-            s.doc.settings.auto_hyphenation = on;
-            Ok(json!({"value": on}))
-        }),
+        CommandSpec::new("layout.lineNumbers", "Line Numbers", "Layout › Page Setup", line_numbers).params(
+            r#"{"value"?: "none|continuous|restartPage|restartSection", "start"?: 1-32767, "countBy"?: 1-100, "distance"?: pt (0 = auto)}"#,
+        ),
+        CommandSpec::new("layout.hyphenation", "Hyphenation", "Layout › Page Setup", hyphenation)
+            .params(r#"{"value"?: bool (automatic; toggles when nothing is given), "zone"?: pt, "caps"?: bool (hyphenate words in capitals), "limit"?: n (consecutive hyphens, 0 = no limit)}"#),
+        CommandSpec::new("layout.manualHyphenation", "Manual Hyphenation", "Layout › Page Setup › Hyphenation", manual_hyphenation)
+            .params(r#"{"from"?: Pos (default: the caret)} → the next word at a line end that could be hyphenated: {"word", "pos", "points": [char index], "suggest": char index} or {"done": true}"#)
+            .pure(),
         CommandSpec::new("layout.pageSetup", "Page Setup", "Layout › Page Setup", |s, v| {
             if let Some(props) = v.get("section") {
                 let new: SectionProps = serde_json::from_value(props.clone()).map_err(|e| CmdError::Params(e.to_string()))?;
@@ -69,6 +60,9 @@ pub fn specs() -> Vec<CommandSpec> {
             with_sect(s, |x| x.rtl = on)
         })
         .params(r#"{"value"?: bool} (true: the section's columns run right to left; without a value it toggles)"#),
+        CommandSpec::new("layout.textDirection", "Text Direction", "Layout › Page Setup", text_direction).params(
+            r#"{"value"?: "horizontal|down|up"} (also lrTb|tbRl|btLr; down: rotate all text 90°, lines top to bottom stacking right to left; up: 270°; default: the next after the current). In a table cell it turns the selected cells, in a text box the box; anywhere else the section(s) of the selection"#,
+        ),
         CommandSpec::new("layout.differentFirstPage", "Different First Page", "Header & Footer › Options", |s, v| {
             let on = p::bool(v, "value").unwrap_or(!sect(s).title_page);
             with_sect(s, |x| x.title_page = on)
@@ -98,6 +92,130 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
+/// Line Numbers: on with a restart mode (`value`), or off (`none`). `start`, `countBy` and
+/// `distance` change the numbering's options and turn it on (keeping its restart mode).
+fn line_numbers(s: &mut Session, v: &Value) -> CmdResult {
+    use wordcraft_doc::section::LineNumberRestart as R;
+    let mode = p::str(v, "value");
+    if mode == Some("none") {
+        return with_sect(s, |x| x.line_numbers = None);
+    }
+    let restart = match mode {
+        Some("restartPage") => Some(R::Page),
+        Some("restartSection") => Some(R::Section),
+        Some("continuous") => Some(R::Continuous),
+        Some(x) => return Err(CmdError::Params(format!("unknown value `{x}`"))),
+        None => None,
+    };
+    let start = p::u64(v, "start").map(|n| n.clamp(1, 32_767) as u32);
+    let count_by = p::u64(v, "countBy").map(|n| n.clamp(1, 100) as u32);
+    let distance = p::f32(v, "distance").map(|d| d.clamp(0.0, 1584.0));
+    let options = start.is_some() || count_by.is_some() || distance.is_some();
+    with_sect(s, |x| {
+        // Options alone keep the current numbering's other settings; a new mode alone starts over.
+        let mut l = match (&x.line_numbers, options) {
+            (Some(cur), true) => cur.clone(),
+            (None, true) => LineNumbering { restart: R::Continuous, ..Default::default() },
+            _ => LineNumbering::default(),
+        };
+        if let Some(r) = restart.or(if options { None } else { Some(R::Continuous) }) {
+            l.restart = r;
+        }
+        if let Some(n) = start {
+            l.start = n;
+        }
+        if let Some(n) = count_by {
+            l.count_by = n;
+        }
+        if let Some(d) = distance {
+            l.distance = d;
+        }
+        x.line_numbers = Some(l);
+    })
+}
+
+/// Hyphenation: automatic on or off, and its options (Hyphenation Options).
+fn hyphenation(s: &mut Session, v: &Value) -> CmdResult {
+    let st = &mut s.doc.settings;
+    let options = ["zone", "caps", "limit"].iter().any(|k| v.get(*k).is_some_and(|x| !x.is_null()));
+    match p::bool(v, "value") {
+        Some(on) => st.auto_hyphenation = on,
+        None if !options => st.auto_hyphenation = !st.auto_hyphenation,
+        None => {}
+    }
+    if let Some(z) = p::f32(v, "zone") {
+        st.hyphenation_zone = z.clamp(0.0, 1584.0);
+    }
+    if let Some(c) = p::bool(v, "caps") {
+        st.hyphenate_caps = c;
+    }
+    if let Some(n) = p::u64(v, "limit") {
+        st.consecutive_hyphen_limit = n.min(32_767) as u32;
+    }
+    Ok(json!({"value": st.auto_hyphenation, "zone": st.hyphenation_zone, "caps": st.hyphenate_caps, "limit": st.consecutive_hyphen_limit}))
+}
+
+/// Manual hyphenation: the next word after `from` that starts a line after a line wrapped at a
+/// space, and could end the line before it if hyphenated. `points` are where a hyphen may go
+/// (char indices into `word`); `suggest` is the last one whose first part fits on that line.
+/// Accepting is `caret.set` to `pos` plus the chosen point, then `text.optionalHyphen`.
+fn manual_hyphenation(s: &mut Session, v: &Value) -> CmdResult {
+    let from = match v.get("from") {
+        Some(f) if !f.is_null() => super::parse_pos(f).ok_or_else(|| CmdError::Params("bad `from`".into()))?,
+        _ => s.sel.ordered().0,
+    };
+    let lim = wordcraft_proof::hyphen::Limits::default();
+    let caps = s.doc.settings.hyphenate_caps;
+    let layout = s.layout();
+    let mut best: Option<(Pos, Value)> = None;
+    for page in &layout.pages {
+        for it in &page.items {
+            let wordcraft_layout::Placed::Lines { story, path, para, l0, l1, .. } = it else { continue };
+            if *story != StoryRef::Body {
+                continue;
+            }
+            let Some(text) = s.doc.para_at(&Pos { story: *story, path: path.clone(), off: 0 }).map(|p| p.text.clone()) else { continue };
+            for li in (*l0).max(1)..*l1 {
+                let (Some(prev), Some(line)) = (para.lines.get(li - 1), para.lines.get(li)) else { continue };
+                if prev.end != wordcraft_layout::LineEnd::Wrap || prev.hyphen.is_some() {
+                    continue;
+                }
+                let at = Pos { story: *story, path: path.clone(), off: line.start };
+                if at < from || best.as_ref().is_some_and(|(b, _)| *b <= at) {
+                    continue;
+                }
+                let Some(rest) = text.get(line.start..) else { continue };
+                let len = rest.char_indices().find(|(_, c)| !(c.is_alphabetic() || *c == '\'' || *c == '\u{2019}')).map_or(rest.len(), |(i, _)| i);
+                let Some(word) = rest.get(..len) else { continue };
+                // A word with an optional hyphen already breaks where its author said.
+                if rest.get(len..).is_some_and(|r| r.starts_with('\u{ad}'))
+                    || word.chars().count() < lim.min_word
+                    || (!caps && word.chars().all(char::is_uppercase))
+                {
+                    continue;
+                }
+                let points = wordcraft_proof::hyphen::hyphen_points(word, &lim);
+                // The room left at the end of the line above, and the width of each first part.
+                let room = prev.right - prev.end_x();
+                let hyphen_w = para
+                    .x_of(li, line.start)
+                    .zip(para.x_of(li, line.start + word.chars().next().map_or(0, char::len_utf8)))
+                    .map_or(6.0, |(a, b)| (b - a) * 0.6);
+                let fits = |pt: usize| {
+                    let bytes = word.char_indices().nth(pt).map_or(word.len(), |(i, _)| i);
+                    match (para.x_of(li, line.start), para.x_of(li, line.start + bytes)) {
+                        (Some(a), Some(b)) => (b - a) + hyphen_w <= room,
+                        _ => false,
+                    }
+                };
+                let Some(suggest) = points.iter().copied().filter(|pt| fits(*pt)).max() else { continue };
+                best = Some((at.clone(), json!({"word": word, "pos": super::pos_json(&at), "points": points, "suggest": suggest})));
+            }
+        }
+    }
+    Ok(best.map(|(_, v)| v).unwrap_or_else(|| json!({"done": true})))
+}
+
 fn block_of(s: &Session) -> usize {
     s.sel.focus.path.0.first().copied().unwrap_or(0) as usize
 }
@@ -121,6 +239,44 @@ pub(crate) fn with_sect(s: &mut Session, f: impl Fn(&mut SectionProps)) -> CmdRe
     Ok(serde_json::to_value(sect(s)).unwrap_or(Value::Null))
 }
 
+/// The text direction Layout › Text Direction would change: the caret cell's, the text box's,
+/// or the section's.
+pub fn text_direction_at(s: &Session) -> wordcraft_doc::props::TextDirection {
+    if let Some((tp, r, c)) = s.sel.focus.path.cell() {
+        return s.doc.table(s.sel.focus.story, &tp).and_then(|t| t.rows.get(r)?.cells.get(c).map(|cl| cl.props.text_direction)).unwrap_or_default();
+    }
+    if let Some((_, id)) = super::objects::text_box_target(s) {
+        return s.doc.parts.get(&id).map(|p| p.body.vert.turn()).unwrap_or_default();
+    }
+    sect(s).text_direction
+}
+
+/// Layout › Text Direction: like Word's button it works on what the caret is in — the selected
+/// table cells, the text box, or else the section.
+fn text_direction(s: &mut Session, v: &Value) -> CmdResult {
+    use wordcraft_doc::props::{TextDirection, TextVert};
+    let dir = match p::str(v, "value") {
+        Some("horizontal" | "lrTb" | "horz") => Some(TextDirection::Horizontal),
+        Some("down" | "tbRl" | "vert" | "rotate90") => Some(TextDirection::Down),
+        Some("up" | "btLr" | "vert270" | "rotate270") => Some(TextDirection::Up),
+        Some(x) => return Err(CmdError::Params(format!("unknown text direction `{x}`"))),
+        None => None,
+    };
+    let dir = dir.unwrap_or(text_direction_at(s).next());
+    if s.sel.focus.path.cell().is_some() {
+        return super::table::text_direction(s, &json!({"value": dir.ooxml()}));
+    }
+    if super::objects::text_box_target(s).is_some() {
+        let vert = match dir {
+            TextDirection::Horizontal => TextVert::Horz,
+            TextDirection::Down => TextVert::Vert,
+            TextDirection::Up => TextVert::Vert270,
+        };
+        return super::objects::set_text_body(s, |b| b.vert = vert);
+    }
+    with_sect(s, |x| x.text_direction = dir)
+}
+
 /// The default font size (Normal style), which the character pitch is based on.
 fn grid_font_size(s: &Session) -> f32 {
     let size = s.doc.styles.resolve_char(Some("Normal"), &wordcraft_doc::CharProps::default()).size;
@@ -353,6 +509,29 @@ mod tests {
         Session::new(wordcraft_doc::Document::from_text("one\ntwo\nthree"))
     }
 
+    /// Layout › Text Direction turns the section, or the table cell the caret is in; one undo step.
+    #[test]
+    fn text_direction_turns_the_section_or_the_cell() {
+        use wordcraft_doc::props::TextDirection;
+        let mut s = doc();
+        s.run("layout.textDirection", &json!({"value": "down"})).unwrap();
+        assert_eq!(sect(&s).text_direction, TextDirection::Down);
+        assert_eq!(text_direction_at(&s), TextDirection::Down);
+        // Without a value: the next one, like Word's button.
+        s.run("layout.textDirection", &json!({})).unwrap();
+        assert_eq!(sect(&s).text_direction, TextDirection::Up);
+        s.run("edit.undo", &json!({})).unwrap();
+        assert_eq!(sect(&s).text_direction, TextDirection::Down);
+        assert!(s.run("layout.textDirection", &json!({"value": "diagonal"})).is_err());
+        assert_eq!(sect(&s).text_direction, TextDirection::Down);
+        // In a table cell it turns the cell, not the section.
+        s.run("insert.table", &json!({"rows": 1, "cols": 2})).unwrap();
+        assert!(s.sel.focus.path.cell().is_some());
+        s.run("layout.textDirection", &json!({"value": "btLr"})).unwrap();
+        assert_eq!(text_direction_at(&s), TextDirection::Up);
+        assert_eq!(sect(&s).text_direction, TextDirection::Down);
+    }
+
     /// More Columns: unequal widths with a line between, as one undo step.
     #[test]
     fn unequal_columns_with_a_line_between() {
@@ -385,4 +564,61 @@ mod tests {
         assert_eq!(s.doc.last_section.start, SectionStart::Continuous);
         assert!(s.run("layout.columns", &json!({"count": 2, "apply": "elsewhere"})).is_err());
     }
+
+    /// #407 Line Numbers options: start, count by, distance and restart; options alone keep the
+    /// restart mode, `none` turns numbering off.
+    #[test]
+    fn line_numbering_options() {
+        use wordcraft_doc::section::LineNumberRestart;
+        let mut s = Session::new(wordcraft_doc::Document::from_text("One\nTwo"));
+        s.run("layout.lineNumbers", &json!({"value": "restartSection", "start": 5, "countBy": 2, "distance": 18})).unwrap();
+        let l = s.doc.last_section.line_numbers.clone().unwrap();
+        assert_eq!((l.start, l.count_by, l.distance, l.restart), (5, 2, 18.0, LineNumberRestart::Section));
+        s.run("layout.lineNumbers", &json!({"countBy": 1e9, "start": -3})).unwrap();
+        let l = s.doc.last_section.line_numbers.clone().unwrap();
+        assert_eq!((l.start, l.count_by, l.restart), (5, 100, LineNumberRestart::Section), "clamped, mode kept");
+        s.run("layout.lineNumbers", &json!({"value": "none"})).unwrap();
+        assert!(s.doc.last_section.line_numbers.is_none());
+        assert!(s.run("layout.lineNumbers", &json!({"value": "sometimes"})).is_err());
+    }
+
+    /// #407 Hyphenation Options: options don't toggle automatic hyphenation; Manual finds a
+    /// word at a line start that would fit hyphenated on the line above, and an optional hyphen
+    /// there breaks the word.
+    #[test]
+    fn hyphenation_options_and_manual_hyphenation() {
+        let mut s = Session::new(wordcraft_doc::Document::from_text(
+            &"a extraordinarily be uncharacteristic of responsibilities the considerations ".repeat(12),
+        ));
+        let r = s.run("layout.hyphenation", &json!({"zone": 36, "caps": false, "limit": 3})).unwrap();
+        assert_eq!(r, json!({"value": false, "zone": 36.0, "caps": false, "limit": 3}));
+        s.run("layout.hyphenation", &json!({})).unwrap();
+        assert!(s.doc.settings.auto_hyphenation, "nothing given toggles");
+        s.run("layout.hyphenation", &json!({"value": false})).unwrap();
+        // Accept every candidate (which words they are depends on the fonts).
+        let mut found = 0;
+        let mut from = json!(null);
+        while found < 5 {
+            let c = s.run("layout.manualHyphenation", &json!({"from": from})).unwrap();
+            if c["done"] == true {
+                break;
+            }
+            let word = c["word"].as_str().unwrap().to_string();
+            let pts = c["points"].as_array().unwrap();
+            assert!(!pts.is_empty() && pts.contains(&c["suggest"]), "{c}");
+            let at = c["suggest"].as_u64().unwrap() as usize;
+            let mut pos = c["pos"].clone();
+            let off = pos["off"].as_u64().unwrap() as usize + word.char_indices().nth(at).unwrap().0;
+            pos["off"] = json!(off);
+            s.run("caret.set", &json!({"pos": pos})).unwrap();
+            s.run("text.optionalHyphen", &json!({})).unwrap();
+            pos["off"] = json!(off + word.len());
+            from = pos;
+            found += 1;
+        }
+        // Some line of thirty or so starts with a long word that fits hyphenated above, whatever the font.
+        assert!(found > 0, "no candidates");
+        assert_eq!(s.doc.plain_text(wordcraft_doc::StoryRef::Body).matches('\u{ad}').count(), found);
+        assert!(s.run("layout.manualHyphenation", &json!({"from": {"block": 999, "off": 0}})).unwrap()["done"] == true);
+    }
 }
diff --git a/crates/engine/src/cmd/para.rs b/crates/engine/src/cmd/para.rs
index 93259d8485..1bb48312fa 100644
--- a/crates/engine/src/cmd/para.rs
+++ b/crates/engine/src/cmd/para.rs
@@ -4,7 +4,7 @@ use serde_json::{Value, json};
 use wordcraft_doc::numbering::ListKind;
 use wordcraft_doc::props::{Align, Border, BorderStyle, Borders, LineSpacing, NumRef, ParaProps, Rgb, TabAlign, TabLeader, TabStop};
 use wordcraft_doc::styles::{Style, StyleKind};
-use wordcraft_doc::{Block, Pos};
+use wordcraft_doc::{Block, CharProps, Pos};
 
 use super::sel_result;
 use crate::{CmdError, CmdResult, CommandSpec, Session, p};
@@ -43,6 +43,7 @@ pub fn specs() -> Vec<CommandSpec> {
                 let l = p.indent_left.unwrap_or(0.0) + 36.0;
                 p.indent_left = Some(l);
                 p.indent_first = Some(-36.0);
+                p.cancel_char_indents(true, false, true);
             })
         })
         .key("Mod+T"),
@@ -50,6 +51,7 @@ pub fn specs() -> Vec<CommandSpec> {
             fmt(s, &|p| {
                 p.indent_left = Some((p.indent_left.unwrap_or(0.0) - 36.0).max(0.0));
                 p.indent_first = Some(0.0);
+                p.cancel_char_indents(true, false, true);
             })
         })
         .key("Mod+Shift+T"),
@@ -65,6 +67,7 @@ pub fn specs() -> Vec<CommandSpec> {
                 if let Some(x) = f {
                     p.indent_first = Some(x.clamp(-1584.0, 1584.0));
                 }
+                p.cancel_char_indents(l.is_some(), r.is_some(), f.is_some());
             })
         })
         .params(r#"{"left"?: pt, "right"?: pt, "firstLine"?: pt (negative = hanging)}"#),
@@ -212,7 +215,17 @@ pub fn specs() -> Vec<CommandSpec> {
 
 /// Resolved paragraph props at the caret.
 fn cur(s: &Session) -> wordcraft_doc::resolve::ResolvedPara {
-    let props = s.doc.para_at(&s.sel.focus).map(|p| p.props.clone()).unwrap_or_default();
+    // A selection ending at the next paragraph's start doesn't format that paragraph (#418), so
+    // its state comes from the last paragraph it does cover.
+    let (a, b) = s.sel.ordered();
+    let mut at = s.sel.focus.clone();
+    if let Some(last) = s.doc.para_paths_in(&a, &b).pop()
+        && last != at.path
+        && at == b
+    {
+        at = Pos { path: last, off: 0, ..at };
+    }
+    let props = s.doc.para_at(&at).map(|p| p.props.clone()).unwrap_or_default();
     s.doc.styles.resolve_para(&props)
 }
 
@@ -299,7 +312,7 @@ fn asian_typography(s: &mut Session, v: &Value) -> CmdResult {
 
 pub fn indent(s: &mut Session, _: &Value) -> CmdResult {
     let (a, b) = s.sel.ordered();
-    let paths = s.doc.paths_between(&a, &b);
+    let paths = s.doc.para_paths_in(&a, &b);
     let tab = s.doc.settings.default_tab.max(1.0);
     for path in paths {
         let (num, left) = {
@@ -309,7 +322,10 @@ pub fn indent(s: &mut Session, _: &Value) -> CmdResult {
         let para = s.doc.para_mut(a.story, &path)?;
         match num {
             Some(n) => para.props.numbering = Some(NumRef { num: n.num, level: (n.level + 1).min(8) }),
-            None => para.props.indent_left = Some(((left / tab).floor() + 1.0) * tab),
+            None => {
+                para.props.indent_left = Some(((left / tab).floor() + 1.0) * tab);
+                para.props.cancel_char_indents(true, false, false);
+            }
         }
         para.touch();
     }
@@ -318,7 +334,7 @@ pub fn indent(s: &mut Session, _: &Value) -> CmdResult {
 
 pub fn outdent(s: &mut Session, _: &Value) -> CmdResult {
     let (a, b) = s.sel.ordered();
-    let paths = s.doc.paths_between(&a, &b);
+    let paths = s.doc.para_paths_in(&a, &b);
     let tab = s.doc.settings.default_tab.max(1.0);
     for path in paths {
         let (num, left) = {
@@ -328,7 +344,10 @@ pub fn outdent(s: &mut Session, _: &Value) -> CmdResult {
         let para = s.doc.para_mut(a.story, &path)?;
         match num {
             Some(n) => para.props.numbering = Some(NumRef { num: n.num, level: n.level.saturating_sub(1) }),
-            None => para.props.indent_left = Some((((left / tab).ceil() - 1.0) * tab).max(0.0)),
+            None => {
+                para.props.indent_left = Some((((left / tab).ceil() - 1.0) * tab).max(0.0));
+                para.props.cancel_char_indents(true, false, false);
+            }
         }
         para.touch();
     }
@@ -394,12 +413,14 @@ fn apply_style(s: &mut Session, v: &Value) -> CmdResult {
             para.format(0, len, &|c| {
                 c.font = None;
                 c.font_cs = None;
+                c.font_ea = None;
                 c.size = None;
                 c.size_cs = None;
                 c.color = None;
             })?;
             para.mark.font = None;
             para.mark.font_cs = None;
+            para.mark.font_ea = None;
             para.mark.size = None;
             para.mark.size_cs = None;
             para.mark.color = None;
@@ -415,7 +436,7 @@ fn list(s: &mut Session, v: &Value, default: ListKind) -> CmdResult {
     let (a, b) = s.sel.ordered();
     // Toggle: if every selected paragraph already has this kind of list, remove it.
     let current: Vec<Option<NumRef>> =
-        s.doc.paths_between(&a, &b).iter().map(|p| s.doc.para(a.story, p).and_then(|x| x.props.numbering).filter(|n| n.num != 0)).collect();
+        s.doc.para_paths_in(&a, &b).iter().map(|p| s.doc.para(a.story, p).and_then(|x| x.props.numbering).filter(|n| n.num != 0)).collect();
     let same_kind = |n: &NumRef| {
         s.doc.numbering.level(n.num, 0).is_some_and(|l| {
             let want = wordcraft_doc::numbering::levels_for(kind);
@@ -431,6 +452,8 @@ fn list(s: &mut Session, v: &Value, default: ListKind) -> CmdResult {
             p.numbering = Some(NumRef { num: 0, level: 0 });
             p.indent_left = None;
             p.indent_first = None;
+            p.indent_left_chars = None;
+            p.indent_first_chars = None;
             if p.style.as_deref() == Some("ListParagraph") {
                 p.style = None;
             }
@@ -454,6 +477,8 @@ fn list(s: &mut Session, v: &Value, default: ListKind) -> CmdResult {
         p.numbering = Some(NumRef { num, level });
         p.indent_left = None;
         p.indent_first = None;
+        p.indent_left_chars = None;
+        p.indent_first_chars = None;
         if p.style.is_none() || p.style.as_deref() == Some("Normal") {
             p.style = Some("ListParagraph".into());
         }
@@ -578,6 +603,10 @@ pub fn border_sides(v: &Value, space_tb: f32, space_lr: f32) -> Result<Borders,
 /// selected paragraph includes its mark). Refused at the top or bottom of the container, next to
 /// a table, across a section break and for a selection across table cells.
 fn move_paras(s: &mut Session, up: bool) -> CmdResult {
+    // Outline view: what's collapsed moves with its heading, past whole shown paragraphs.
+    if let Some(r) = super::outline::move_shown(s, up) {
+        return r;
+    }
     let (a, b) = s.sel.ordered();
     if a.story != b.story || a.path.parent() != b.path.parent() {
         return Err(CmdError::Failed("select paragraphs in one place (not across table cells) to move them".into()));
@@ -641,6 +670,17 @@ fn heading_level(s: &Session, props: &ParaProps) -> Option<u8> {
     s.doc.styles.resolve_para(props).outline_level.filter(|l| *l < 9).map(|l| l + 1)
 }
 
+/// Give paragraph `path` Heading `level` (1–9), or make it body text (`None`: the default
+/// paragraph style); its own outline level goes, so the style's counts.
+pub(crate) fn set_heading(s: &mut Session, story: wordcraft_doc::StoryRef, path: &wordcraft_doc::Path, level: Option<u8>) -> Result<(), CmdError> {
+    let style = level.map(|n| ensure_heading_style(s, n.clamp(1, 9)));
+    let para = s.doc.para_mut(story, path)?;
+    para.props.style = style;
+    para.props.outline_level = None;
+    para.touch();
+    Ok(())
+}
+
 /// Make sure the built-in `Heading{n}` style (and its linked character style) is in the
 /// document, for files that didn't bring it.
 fn ensure_heading_style(s: &mut Session, n: u8) -> String {
@@ -664,6 +704,8 @@ fn ensure_heading_style(s: &mut Session, n: u8) -> String {
 /// promoted becomes a heading at the level of the heading before it (Heading 1 when there is
 /// none) and can't be demoted further; a list item changes list level like Shift+Tab / Tab.
 fn outline_step(s: &mut Session, promote: bool) -> CmdResult {
+    // Outline view: the headings hidden under a collapsed heading move a level with it.
+    let carried = super::outline::hidden_subheadings(s);
     let (a, b) = s.sel.ordered();
     let paths = s.doc.paths_between(&a, &b);
     // The heading before the selection, for promoted body text.
@@ -706,6 +748,12 @@ fn outline_step(s: &mut Session, promote: bool) -> CmdResult {
     if !changed {
         return Err(CmdError::Failed(if promote { "nothing to promote".into() } else { "nothing to demote".into() }));
     }
+    for (j, h) in carried {
+        let n = if promote { h.saturating_sub(1).max(1) } else { (h + 1).min(9) };
+        if n != h {
+            set_heading(s, wordcraft_doc::StoryRef::Body, &wordcraft_doc::Path::top(j), Some(n))?;
+        }
+    }
     sel_result(s)
 }
 
@@ -819,8 +867,7 @@ fn create_style(s: &mut Session, v: &Value) -> CmdResult {
 
 fn modify_style(s: &mut Session, v: &Value) -> CmdResult {
     let id = style_id(s, p::req_str(v, "style")?)?;
-    let chr: Option<wordcraft_doc::CharProps> =
-        v.get("chr").map(|c| serde_json::from_value(c.clone())).transpose().map_err(|e| CmdError::Params(e.to_string()))?;
+    let chr: Option<CharProps> = v.get("chr").map(|c| serde_json::from_value(c.clone())).transpose().map_err(|e| CmdError::Params(e.to_string()))?;
     let para: Option<ParaProps> =
         v.get("para").map(|c| serde_json::from_value(c.clone())).transpose().map_err(|e| CmdError::Params(e.to_string()))?;
     let next = p::str(v, "next").map(str::to_string);
@@ -843,36 +890,108 @@ fn modify_style(s: &mut Session, v: &Value) -> CmdResult {
     sel_result(s)
 }
 
+/// Update Style to Match Selection: the style takes on how the selection looks — its paragraph
+/// style, character style and direct formatting, read at the start of the selection — so every
+/// paragraph using the style changes. A paragraph style is then applied to the selected
+/// paragraphs, whose direct formatting the style now carries is dropped (other direct formatting,
+/// a bold word say, stays). The style keeps its outline level and list numbering.
 fn update_to_match(s: &mut Session, v: &Value) -> CmdResult {
-    let f = s.sel.focus.clone();
-    let Some(para) = s.doc.para_at(&f).cloned() else { return sel_result(s) };
+    let (a, b) = s.sel.ordered();
+    let Some(para) = s.doc.para_at(&a).cloned() else { return sel_result(s) };
     let id = match p::str(v, "style") {
         Some(n) => style_id(s, n)?,
         None => para.props.style.clone().unwrap_or_else(|| "Normal".into()),
     };
-    let mut chr = para.props_at(f.off).clone();
-    chr.style = None;
-    chr.link = None;
-    chr.ins = None;
-    chr.del = None;
-    chr.fmt_change = None;
-    let mut pp = para.props.formatting();
-    pp.style = None;
-    pp.numbering = None;
-    if let Some(st) = s.doc.styles.get_mut(&id) {
-        st.chr.overlay(&chr);
-        st.para.overlay(&pp);
+    let sheet = &s.doc.styles;
+    let Some(target) = sheet.get(&id).cloned() else { return Err(CmdError::Params(format!("no style `{id}`"))) };
+    if !matches!(target.kind, StyleKind::Paragraph | StyleKind::Character) {
+        return Err(CmdError::Failed(format!("`{}` can't be updated to match the selection", target.name)));
     }
-    // Remove the now-redundant direct formatting from the paragraph.
-    let p = s.doc.para_mut(f.story, &f.path)?;
-    let len = p.len();
-    p.format(0, len, &|c| *c = c.cleared())?;
-    let style = p.props.style.clone();
-    p.props = ParaProps { style, numbering: p.props.numbering, ..Default::default() };
+    let direct = if s.sel.is_collapsed() { para.props_at(a.off) } else { para.props_of_char(a.off) }.clone();
+    let para_style = para.props.style.clone().unwrap_or_else(|| "Normal".into());
+    // How the selection looks: document defaults, its paragraph style chain, its character
+    // style chain, direct formatting (the resolve order, before defaults are filled in).
+    let (mut want_p, mut want_c) = sheet.para_style_props(&para_style);
+    let char_chain = |c: &mut CharProps, style: Option<&str>| {
+        for st in style.map(|cs| sheet.chain(cs)).unwrap_or_default() {
+            if matches!(st.kind, StyleKind::Character | StyleKind::Paragraph) {
+                c.overlay(&st.chr);
+            }
+        }
+    };
+    char_chain(&mut want_c, direct.style.as_deref());
+    want_c.overlay(&CharProps { style: None, ..direct.formatting() });
+    want_p.overlay(&ParaProps { style: None, numbering: None, ..para.props.formatting() });
+    // How the style looks now, in the same terms.
+    let (have_p, have_c) = match target.kind {
+        StyleKind::Character => {
+            let (pp, mut cc) = sheet.para_style_props(&para_style);
+            char_chain(&mut cc, Some(&id));
+            (pp, cc)
+        }
+        _ => sheet.para_style_props(&id),
+    };
+    let chr = retarget(&target.chr, &have_c, &want_c, CHAR_KEEP)?;
+    let pp = if target.kind == StyleKind::Paragraph { retarget(&target.para, &have_p, &want_p, PARA_KEEP)? } else { target.para.clone() };
+    if let Some(st) = s.doc.styles.get_mut(&id) {
+        st.chr = chr;
+        st.para = pp;
+    }
+    if target.kind == StyleKind::Paragraph {
+        // The selected paragraphs take the style; what it now gives them needn't stay direct.
+        let paths = s.doc.paths_between(&a, &b);
+        for path in paths {
+            let p = s.doc.para_mut(a.story, &path)?;
+            p.props.style = Some(id.clone());
+            p.props = strip_matching(&p.props, &want_p, PARA_KEEP);
+            let len = p.len();
+            p.format(0, len, &|c| *c = strip_matching(c, &want_c, CHAR_KEEP))?;
+            p.mark = strip_matching(&p.mark, &want_c, CHAR_KEEP);
+        }
+    }
+    s.pending = None;
     touch_all(s);
     sel_result(s)
 }
 
+/// Character properties Update to Match leaves alone: the character style, links and revisions.
+const CHAR_KEEP: &[&str] = &["style", "link", "ins", "del", "fmtChange"];
+/// Paragraph properties Update to Match leaves alone: the style, its outline level (a heading
+/// stays a heading), list numbering and revisions.
+const PARA_KEEP: &[&str] = &["style", "outlineLevel", "numbering", "numChange", "fmtChange"];
+
+fn props_map<T: serde::Serialize>(t: &T) -> serde_json::Map<String, Value> {
+    match serde_json::to_value(t) {
+        Ok(Value::Object(m)) => m,
+        _ => serde_json::Map::new(),
+    }
+}
+
+/// A style's own properties `own`, changed so that its chain gives `want` where it gave `have`:
+/// a property that differs is set to the wanted value, or dropped (inherited again) when the
+/// selection doesn't set it at all.
+fn retarget<T: serde::Serialize + serde::de::DeserializeOwned>(own: &T, have: &T, want: &T, keep: &[&str]) -> Result<T, CmdError> {
+    let (mut out, have, want) = (props_map(own), props_map(have), props_map(want));
+    let keys: std::collections::BTreeSet<&String> = have.keys().chain(want.keys()).collect();
+    for k in keys {
+        if keep.contains(&k.as_str()) || have.get(k) == want.get(k) {
+            continue;
+        }
+        match want.get(k) {
+            Some(v) => out.insert(k.clone(), v.clone()),
+            None => out.remove(k),
+        };
+    }
+    serde_json::from_value(Value::Object(out)).map_err(|e| CmdError::Failed(e.to_string()))
+}
+
+/// `direct` without the properties that have the same value in `inherited` (outside `keep`).
+fn strip_matching<T: serde::Serialize + serde::de::DeserializeOwned + Clone>(direct: &T, inherited: &T, keep: &[&str]) -> T {
+    let (mut out, inherited) = (props_map(direct), props_map(inherited));
+    out.retain(|k, v| keep.contains(&k.as_str()) || inherited.get(k) != Some(v));
+    serde_json::from_value(Value::Object(out)).unwrap_or_else(|_| direct.clone())
+}
+
 /// Delete a custom style. Text that uses it falls back to the style it was based on (or the
 /// default style), styles based on it are rebased, and a custom character style linked to it
 /// goes with it. Built-in styles are refused.
diff --git a/crates/engine/src/cmd/paste.rs b/crates/engine/src/cmd/paste.rs
index 1b0fb79d9a..dcb3d36992 100644
--- a/crates/engine/src/cmd/paste.rs
+++ b/crates/engine/src/cmd/paste.rs
@@ -111,7 +111,7 @@ fn paste_special(s: &mut Session, v: &Value) -> CmdResult {
     };
     let frag = match fmt {
         "text" => {
-            super::type_text(s, &src.replace('\n', "\r"))?;
+            super::paste_text(s, &src.replace("\r\n", "\r").replace('\n', "\r"))?;
             let mut r = sel_result(s)?;
             r["pastedAs"] = json!(fmt);
             return Ok(r);
@@ -128,6 +128,7 @@ fn paste_special(s: &mut Session, v: &Value) -> CmdResult {
 
 /// Replace the selection with `frag`, marking it as an insertion under Track Changes.
 pub fn insert(s: &mut Session, mut frag: Fragment) -> Result<(), CmdError> {
+    super::controls::prepare_edit(s)?;
     let at = delete_selection(s)?;
     let track = s.doc.settings.track_changes;
     let mut rid = None;
@@ -151,7 +152,8 @@ pub fn insert(s: &mut Session, mut frag: Fragment) -> Result<(), CmdError> {
         }
     }
     let end = s.doc.insert_fragment(&at, &frag)?;
-    // The paragraph marks the paste added are inserted too.
+    // The paragraph marks the paste added are inserted too, so rejecting it joins the
+    // paragraphs again. The last paragraph ends with the original mark and keeps it.
     if let Some(r) = rid
         && at.story == end.story
         && at.path.parent() == end.path.parent()
diff --git a/crates/engine/src/cmd/protect.rs b/crates/engine/src/cmd/protect.rs
new file mode 100644
index 0000000000..396385aa4b
--- /dev/null
+++ b/crates/engine/src/cmd/protect.rs
@@ -0,0 +1,428 @@
+//! Restrict Editing (Review › Protect, #412): editing restrictions (read only, comments, tracked
+//! changes, filling in forms), formatting limited to a selection of styles, exceptions — ranges
+//! everyone may still edit (`w:permStart w:edGrp="everyone"`) — and an optional password that
+//! guards Stop Protection (ECMA-376 §17.15.1.29; the hash is in `wordcraft_docx`).
+//!
+//! Enforcement lives in [`crate::Session::run`]: [`check_before`] refuses commands the
+//! restrictions forbid outright, and while exceptions exist [`outside_unchanged`] checks after the
+//! command that nothing outside them changed (the command is rolled back otherwise).
+
+use serde_json::{Value, json};
+use wordcraft_doc::para::{InlineObject, OBJ};
+use wordcraft_doc::props::CharProps;
+use wordcraft_doc::{Document, PermRange, Pos, StoryRef};
+
+use crate::{CmdError, CmdResult, CommandSpec, Session, p};
+
+/// The editing restrictions `w:edit` names.
+const MODES: [&str; 5] = ["none", "readOnly", "comments", "trackedChanges", "forms"];
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec::new("review.restrict", "Restrict Editing", "Review › Protect", restrict).params(
+            r#"{"mode"?: "none|readOnly|comments|trackedChanges|forms" (start enforcing; "none" stops), "formatting"?: bool (limit formatting to unlocked styles), "lockedStyles"?: [style id or name] (the styles that can't be applied; every other style is unlocked), "password"?: string (set when enforcing; required to stop a password-protected document), "stop"?: bool, "exception"?: "add" (the selection stays editable for everyone) | "remove" (exceptions touching the selection) | "removeAll"} → state"#,
+        ),
+    ]
+}
+
+/// The protection state, as `review.restrict` returns it and the Restrict Editing pane shows it.
+pub fn state(s: &Session) -> Value {
+    let st = &s.doc.settings;
+    let regions: Vec<Value> =
+        s.doc.perm_ranges().iter().filter(|r| editable_by(r, &s.author)).map(|r| json!({"start": r.start, "end": r.end})).collect();
+    json!({
+        "protection": st.protection,
+        "formatting": st.protect_formatting,
+        "password": !st.protect_hash.is_empty(),
+        "lockedStyles": s.doc.styles.styles.iter().filter(|x| x.locked).map(|x| x.id.clone()).collect::<Vec<_>>(),
+        "exceptions": regions.len(),
+        "regions": regions,
+    })
+}
+
+/// Is the document's editing or formatting restricted?
+pub fn enforced(doc: &Document) -> bool {
+    doc.settings.protection.is_some()
+}
+
+/// May `author` edit inside the range?
+fn editable_by(r: &PermRange, author: &str) -> bool {
+    r.everyone() || (!r.editor.is_empty() && r.editor.eq_ignore_ascii_case(author.trim()))
+}
+
+fn restrict(s: &mut Session, v: &Value) -> CmdResult {
+    if let Some(e) = p::str(v, "exception") {
+        if enforced(&s.doc) {
+            return Err(CmdError::Disabled("stop protection before changing the exceptions".into()));
+        }
+        match e {
+            "add" => add_exception(s)?,
+            "remove" => remove_exceptions(s, false)?,
+            "removeAll" => remove_exceptions(s, true)?,
+            _ => return Err(CmdError::Params("`exception` is \"add\", \"remove\" or \"removeAll\"".into())),
+        }
+        return Ok(state(s));
+    }
+    if let Some(list) = v.get("lockedStyles") {
+        let Some(list) = list.as_array() else { return Err(CmdError::Params("`lockedStyles` is a list of style ids or names".into())) };
+        if enforced(&s.doc) {
+            return Err(CmdError::Disabled("stop protection before changing the formatting restrictions".into()));
+        }
+        let names: Vec<&str> = list.iter().filter_map(Value::as_str).take(10_000).collect();
+        for st in &mut s.doc.styles.styles {
+            st.locked = names.iter().any(|n| *n == st.id || n.eq_ignore_ascii_case(&st.name));
+        }
+    }
+    let mode = p::str(v, "mode");
+    if let Some(m) = mode
+        && !MODES.contains(&m)
+    {
+        return Err(CmdError::Params(format!("unknown `mode` {m:?}: none, readOnly, comments, trackedChanges or forms")));
+    }
+    let formatting = p::bool(v, "formatting");
+    let stop = p::bool(v, "stop") == Some(true) || (mode == Some("none") && formatting != Some(true));
+    if stop {
+        return stop_protection(s, p::str(v, "password").unwrap_or(""));
+    }
+    if mode.is_none() && formatting.is_none() {
+        // Only the locked styles changed (or nothing): report the state.
+        return Ok(state(s));
+    }
+    if enforced(&s.doc) && !s.doc.settings.protect_hash.is_empty() {
+        return Err(CmdError::Disabled("the document is protected with a password: stop protection first".into()));
+    }
+    let formatting = formatting.unwrap_or(false);
+    let mode = mode.unwrap_or("none");
+    if mode == "none" && !formatting {
+        return stop_protection(s, "");
+    }
+    let hash = match p::str(v, "password").filter(|p| !p.is_empty()) {
+        Some(pw) => wordcraft_docx::protection_hash(pw, wordcraft_docx::DEFAULT_SPIN_COUNT).map_err(|e| CmdError::Params(e.to_string()))?,
+        None => Vec::new(),
+    };
+    let st = &mut s.doc.settings;
+    st.protection = Some(mode.to_string());
+    st.protect_formatting = formatting;
+    st.protect_hash = hash;
+    if mode == "trackedChanges" {
+        st.track_changes = true;
+    }
+    Ok(state(s))
+}
+
+/// The error Stop Protection reports when the document's password hash uses an algorithm or form
+/// WordCraft can't check; the protection stays on.
+pub const UNSUPPORTED_PASSWORD: &str = "This password type isn't supported";
+
+/// Stop Protection: with the document's password when it has one. The password is checked like
+/// Word checks it — the current hash form and the legacy one (ECMA-376 Part 4 §14.8.1); a hash
+/// WordCraft can't check refuses ([`UNSUPPORTED_PASSWORD`]) rather than unlocking.
+fn stop_protection(s: &mut Session, password: &str) -> CmdResult {
+    if enforced(&s.doc) {
+        use wordcraft_docx::PasswordCheck;
+        match wordcraft_docx::check_protection_password(&s.doc.settings.protect_hash, password) {
+            PasswordCheck::NoPassword | PasswordCheck::Correct => {}
+            PasswordCheck::Incorrect if password.is_empty() => {
+                return Err(CmdError::Params("type the document's password to stop protection".into()));
+            }
+            PasswordCheck::Incorrect => return Err(CmdError::Params("the password is incorrect".into())),
+            PasswordCheck::Unsupported => return Err(CmdError::Disabled(UNSUPPORTED_PASSWORD.into())),
+        }
+    }
+    let st = &mut s.doc.settings;
+    st.protection = None;
+    st.protect_formatting = false;
+    st.protect_hash.clear();
+    Ok(state(s))
+}
+
+/// Make the selection an exception everyone may edit.
+fn add_exception(s: &mut Session) -> Result<(), CmdError> {
+    let (a, b) = s.sel.ordered();
+    if a == b || a.story != b.story {
+        return Err(CmdError::Params("select the text that stays editable".into()));
+    }
+    let id = s.doc.perm_ranges().iter().map(|r| r.id).max().map_or(0, |m| m.saturating_add(1));
+    let props = CharProps::default();
+    // The end first: inserting it can't move the start.
+    s.doc.insert_object(&b, InlineObject::PermEnd { id }, &props)?;
+    let after_start = s.doc.insert_object(&a, InlineObject::PermStart { id, group: "everyone".into(), editor: String::new() }, &props)?;
+    let mut end = b.clone();
+    if end.path == a.path && end.story == a.story {
+        end.off += OBJ.len_utf8();
+    }
+    s.sel = crate::Selection { anchor: after_start, focus: end };
+    Ok(())
+}
+
+/// Remove the exceptions that touch the selection (or all of them).
+fn remove_exceptions(s: &mut Session, all: bool) -> Result<(), CmdError> {
+    let (a, b) = s.sel.ordered();
+    let ids: Vec<u32> =
+        s.doc.perm_ranges().iter().filter(|r| all || (r.start.story == a.story && r.start <= b && a <= r.end)).map(|r| r.id).collect();
+    if ids.is_empty() {
+        return Ok(());
+    }
+    let stories: Vec<StoryRef> = std::iter::once(StoryRef::Body).chain(s.doc.parts.keys().map(|k| StoryRef::Part(*k))).collect();
+    for story in stories {
+        for path in s.doc.para_paths(story) {
+            let Some(p) = s.doc.para(story, &path) else { continue };
+            let marks: Vec<usize> = p
+                .object_offsets()
+                .into_iter()
+                .filter(
+                    |off| matches!(p.object_at(*off), Some(InlineObject::PermStart { id, .. } | InlineObject::PermEnd { id }) if ids.contains(id)),
+                )
+                .collect();
+            if marks.is_empty() {
+                continue;
+            }
+            let para = s.doc.para_mut(story, &path)?;
+            for off in marks.into_iter().rev() {
+                para.delete(off, off + OBJ.len_utf8())?;
+            }
+        }
+    }
+    s.clamp_selection();
+    Ok(())
+}
+
+/// Commands always allowed in a protected document: protection itself, file commands, undo.
+fn always_allowed(id: &str) -> bool {
+    id == "review.restrict" || id.starts_with("file.") || id == "edit.undo" || id == "edit.redo"
+}
+
+/// What a protected document lets command `id` do before it runs: `Err` refuses it; `Ok(true)`
+/// lets it run as long as it only changes the exceptions (checked afterwards with
+/// [`outside_unchanged`]).
+pub(crate) fn check_before(s: &Session, id: &str, params: &Value) -> Result<bool, CmdError> {
+    let Some(mode) = s.doc.settings.protection.as_deref() else { return Ok(false) };
+    if always_allowed(id) {
+        return Ok(false);
+    }
+    if s.doc.settings.protect_formatting {
+        check_formatting(s, id, params)?;
+    }
+    let comment_ok = id.starts_with("review.") && (id.contains("Comment") || id == "review.reply");
+    let exceptions = || s.doc.perm_ranges().iter().any(|r| editable_by(r, &s.author));
+    match mode {
+        "readOnly" if exceptions() => Ok(true),
+        "readOnly" | "forms" => Err(CmdError::Disabled(format!("{id}: the document is protected (read only)"))),
+        "comments" if comment_ok => Ok(false),
+        "comments" if exceptions() => Ok(true),
+        "comments" => Err(CmdError::Disabled(format!("{id}: only comments are allowed in this document"))),
+        _ => Ok(false),
+    }
+}
+
+/// Formatting limited to a selection of styles: no direct formatting, and no locked style.
+fn check_formatting(s: &Session, id: &str, params: &Value) -> Result<(), CmdError> {
+    let style = match id {
+        "para.style" | "format.charStyle" => p::str(params, "style"),
+        "para.normal" => Some("Normal"),
+        "para.heading1" => Some("Heading1"),
+        "para.heading2" => Some("Heading2"),
+        "para.heading3" => Some("Heading3"),
+        _ => None,
+    };
+    if let Some(name) = style {
+        let locked = s.doc.styles.styles.iter().any(|st| st.locked && (st.id == name || st.name.eq_ignore_ascii_case(name)));
+        return if locked { Err(CmdError::Disabled(format!("{id}: the style {name:?} is locked in this document"))) } else { Ok(()) };
+    }
+    let direct = (id.starts_with("format.") && !matches!(id, "format.changeCase" | "format.state" | "format.fontDialog"))
+        || (id.starts_with("para.") && !matches!(id, "para.sort" | "para.dialog"))
+        || id.starts_with("styles.create")
+        || id.starts_with("styles.modify")
+        || id.starts_with("styles.update")
+        || id.starts_with("styles.delete");
+    if direct {
+        return Err(CmdError::Disabled(format!("{id}: formatting is limited to the document's styles")));
+    }
+    Ok(())
+}
+
+/// Did a command leave everything outside the exceptions as it was? Compares the text, run
+/// formatting and paragraph formatting outside the ranges `author` may edit, in every story.
+pub(crate) fn outside_unchanged(before: &Document, after: &Document, author: &str) -> bool {
+    outside(before, author) == outside(after, author)
+}
+
+/// One piece of protected content: text with its formatting, or a paragraph mark's formatting.
+#[derive(PartialEq)]
+enum Piece {
+    Text(String, CharProps),
+    Object(Option<InlineObject>),
+    Mark(Box<wordcraft_doc::ParaProps>, CharProps),
+}
+
+/// Everything outside the editable ranges, in order.
+fn outside(doc: &Document, author: &str) -> Vec<Piece> {
+    let editable: Vec<u32> = doc.perm_ranges().iter().filter(|r| editable_by(r, author)).map(|r| r.id).collect();
+    let mut out = Vec::new();
+    let stories = std::iter::once(StoryRef::Body).chain(doc.parts.keys().map(|k| StoryRef::Part(*k)));
+    for story in stories {
+        let mut open: Vec<u32> = Vec::new();
+        for path in doc.para_paths(story) {
+            let Some(p) = doc.para(story, &path) else { continue };
+            let mut k = 0;
+            for (r, props) in p.run_ranges() {
+                let Some(text) = p.text.get(r.clone()) else { continue };
+                let mut piece = String::new();
+                for (i, c) in text.char_indices() {
+                    if c == OBJ {
+                        let obj = p.objects.get(k);
+                        k += 1;
+                        match obj {
+                            Some(InlineObject::PermStart { id, .. }) if editable.contains(id) => {
+                                flush(&mut out, &mut piece, props, &open);
+                                open.push(*id);
+                                continue;
+                            }
+                            Some(InlineObject::PermEnd { id }) if editable.contains(id) => {
+                                flush(&mut out, &mut piece, props, &open);
+                                if let Some(j) = open.iter().rposition(|x| x == id) {
+                                    open.remove(j);
+                                }
+                                continue;
+                            }
+                            _ => {}
+                        }
+                        if open.is_empty() {
+                            flush(&mut out, &mut piece, props, &open);
+                            out.push(Piece::Object(obj.cloned()));
+                        }
+                        let _ = i;
+                        continue;
+                    }
+                    if open.is_empty() {
+                        piece.push(c);
+                    }
+                }
+                flush(&mut out, &mut piece, props, &open);
+            }
+            if open.is_empty() {
+                out.push(Piece::Mark(Box::new(p.props.clone()), p.mark.clone()));
+            }
+        }
+    }
+    out
+}
+
+fn flush(out: &mut Vec<Piece>, piece: &mut String, props: &CharProps, open: &[u32]) {
+    if !piece.is_empty() && open.is_empty() {
+        out.push(Piece::Text(std::mem::take(piece), props.clone()));
+    }
+    piece.clear();
+}
+
+/// Did undo or redo take protection away (it may only be lifted with Stop Protection)?
+pub(crate) fn protection_lifted(before: &Document, after: &Document) -> bool {
+    let (b, a) = (&before.settings, &after.settings);
+    b.protection.is_some() && (a.protection != b.protection || a.protect_formatting != b.protect_formatting || a.protect_hash != b.protect_hash)
+}
+
+/// The first position in an editable range after `from` (wrapping round), for Find Next Region
+/// I Can Edit; with it, the range's end.
+pub fn next_region(s: &Session, from: &Pos) -> Option<(Pos, Pos)> {
+    let ranges: Vec<PermRange> = s.doc.perm_ranges().into_iter().filter(|r| editable_by(r, &s.author)).collect();
+    let next = ranges.iter().find(|r| r.start > *from).or_else(|| ranges.first())?;
+    Some((next.start.clone(), next.end.clone()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Selection;
+
+    fn select(s: &mut Session, text: &str) {
+        s.run("select.text", &json!({"text": text})).unwrap();
+    }
+
+    #[test]
+    fn read_only_with_an_exception_allows_edits_only_inside_it() {
+        let mut s = Session::new(Document::from_text("Locked intro.\nFill in here.\nLocked end."));
+        select(&mut s, "Fill in here.");
+        s.run("review.restrict", &json!({"exception": "add"})).unwrap();
+        s.run("review.restrict", &json!({"mode": "readOnly"})).unwrap();
+        // Inside the exception: typing works.
+        select(&mut s, "here");
+        s.run("text.insert", &json!({"text": "there"})).unwrap();
+        assert!(s.doc.plain_text(StoryRef::Body).contains("Fill in there."));
+        // Outside it: refused, and the document is as it was.
+        let before = s.doc.plain_text(StoryRef::Body);
+        select(&mut s, "intro");
+        assert!(s.run("text.insert", &json!({"text": "x"})).is_err());
+        assert!(s.run("format.bold", &json!({})).is_err());
+        // Backspace at the start of the exception would delete outside it.
+        let start = s.doc.perm_ranges()[0].start.clone();
+        s.sel = Selection::caret(start);
+        assert!(s.run("text.backspace", &json!({})).is_err());
+        assert_eq!(s.doc.plain_text(StoryRef::Body), before);
+        // Undo can't lift the protection.
+        for _ in 0..5 {
+            let _ = s.run("edit.undo", &json!({}));
+        }
+        assert_eq!(s.doc.settings.protection.as_deref(), Some("readOnly"));
+    }
+
+    #[test]
+    fn password_guards_stop_protection_and_survives_docx() {
+        let mut s = Session::new(Document::from_text("Secret plan.\nEditable part."));
+        select(&mut s, "Editable part.");
+        s.run("review.restrict", &json!({"exception": "add"})).unwrap();
+        s.run("review.restrict", &json!({"mode": "readOnly", "password": "pw1", "formatting": true, "lockedStyles": ["Heading1"]})).unwrap();
+        let bytes = crate::io::save_bytes("x.docx", &s.doc).unwrap();
+        let doc = crate::io::open_bytes("x.docx", &bytes).unwrap();
+        let st = &doc.settings;
+        assert_eq!(st.protection.as_deref(), Some("readOnly"));
+        assert!(st.protect_formatting);
+        assert!(st.protect_hash.iter().any(|(k, v)| k == "w:algorithmName" && v == "SHA-512"));
+        assert!(doc.styles.get("Heading1").is_some_and(|x| x.locked));
+        let r = doc.perm_ranges();
+        assert_eq!(r.len(), 1);
+        assert!(r[0].everyone());
+        let mut t = Session::new(doc);
+        assert!(t.run("review.restrict", &json!({"stop": true, "password": "wrong"})).is_err());
+        assert!(t.run("review.restrict", &json!({"mode": "none"})).is_err());
+        assert!(t.run("para.heading1", &json!({})).is_err(), "locked style");
+        t.run("review.restrict", &json!({"stop": true, "password": "pw1"})).unwrap();
+        assert!(t.doc.settings.protection.is_none());
+        // The password isn't kept for Repeat or macros.
+        assert!(t.last_command.as_ref().is_none_or(|(_, p)| p.get("password").is_none()));
+    }
+
+    /// A Word file with the legacy hash (`w:cryptAlgorithmSid`): a wrong password is rejected, the
+    /// right one unlocks; a hash WordCraft can't check never unlocks.
+    #[test]
+    fn legacy_password_is_verified_and_unknown_forms_refused() {
+        let protected = |sid: &str| {
+            let mut doc = Document::from_text("Locked.");
+            doc.settings.protection = Some("readOnly".into());
+            doc.settings.protect_hash = [
+                ("w:cryptProviderType", "rsaFull"),
+                ("w:cryptAlgorithmClass", "hash"),
+                ("w:cryptAlgorithmType", "typeAny"),
+                ("w:cryptAlgorithmSid", sid),
+                ("w:cryptSpinCount", "100000"),
+                // SHA-1 of salt 00…0F + Word's legacy key for "Example" (ECMA-376 Part 4 §14.8.1).
+                ("w:hash", "pEWelKoH6SVpvMmyPAJ8bHA/g/s="),
+                ("w:salt", "AAECAwQFBgcICQoLDA0ODw=="),
+            ]
+            .iter()
+            .map(|(k, v)| (k.to_string(), v.to_string()))
+            .collect();
+            Session::new(doc)
+        };
+        let mut s = protected("4");
+        assert!(s.run("review.restrict", &json!({"stop": true, "password": "wrong"})).is_err());
+        assert!(s.run("review.restrict", &json!({"stop": true, "password": ""})).is_err());
+        assert!(super::enforced(&s.doc));
+        s.run("review.restrict", &json!({"stop": true, "password": "Example"})).unwrap();
+        assert!(!super::enforced(&s.doc));
+        // MD2 isn't supported: refused whatever the password.
+        let mut s = protected("1");
+        let e = s.run("review.restrict", &json!({"stop": true, "password": "anything"})).unwrap_err();
+        assert!(e.to_string().contains(super::UNSUPPORTED_PASSWORD));
+        assert!(super::enforced(&s.doc));
+    }
+}
diff --git a/crates/engine/src/cmd/references.rs b/crates/engine/src/cmd/references.rs
index 0ec7a54d01..4c28a5091e 100644
--- a/crates/engine/src/cmd/references.rs
+++ b/crates/engine/src/cmd/references.rs
@@ -10,8 +10,9 @@ use crate::{CmdError, CmdResult, CommandSpec, Selection, Session, p};
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
-        CommandSpec::new("references.toc", "Table of Contents", "References › Table of Contents", insert_toc)
-            .params(r#"{"levels"?: 1-9, "title"?: string}"#),
+        CommandSpec::new("references.toc", "Table of Contents", "References › Table of Contents", insert_toc).params(
+            r#"{"levels"?: 1-9, "title"?: string, "pageNumbers"?: bool, "rightAlign"?: bool, "tabLeader"?: "dot|hyphen|underscore|none", "hyperlinks"?: bool, "headingStyles"?: bool, "outlineLevels"?: bool, "tcFields"?: bool, "styleLevels"?: {style name: 1-9}} (replaces an existing table; {} updates it)"#,
+        ),
         CommandSpec::new("references.updateToc", "Update Table", "References › Table of Contents", |s, _| {
             update_toc(s)?;
             sel_result(s)
@@ -67,7 +68,7 @@ pub fn specs() -> Vec<CommandSpec> {
         })
         .pure(),
         CommandSpec::new("references.caption", "Insert Caption", "References › Captions", caption)
-            .params(r#"{"label"?: "Figure|Table|Equation", "text"?: string}"#),
+            .params(r#"{"label"?: "Figure|Table|Equation|any label", "text"?: string, "position"?: "below|above", "excludeLabel"?: bool, "format"?: "ARABIC|alphabetic|ALPHABETIC|roman|ROMAN", "chapter"?: heading level 1-9, "separator"?: "-|.|:|—|–"}"#),
         // F9: update fields; the selected ones that showed their code show their result again.
         CommandSpec::new("references.updateFields", "Update Field", "References", |s, _| {
             update_fields(s)?;
@@ -78,8 +79,170 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
-/// Headings (outline level < levels) in the body: (path, level, text).
-fn headings(s: &Session, levels: u8) -> Vec<(Path, u8, String)> {
+/// A field instruction split into its name, positional arguments and switches (ECMA-376
+/// §17.16.1): `TOC \o "1-3" \h` → name `TOC`, switches `o` = `1-3` and `h`. Quoted text stays
+/// whole (without the quotes; `\"` and `\\` inside it are a quote and a backslash). A switch
+/// takes the word after it as its argument unless that word is another switch.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct FieldCode {
+    pub name: String,
+    pub args: Vec<String>,
+    /// Switch letter (lower-cased; `*`, `@`, `#` for the general switches) and argument.
+    pub switches: Vec<(char, Option<String>)>,
+}
+
+impl FieldCode {
+    pub fn parse(instr: &str) -> FieldCode {
+        let mut words: Vec<(String, bool)> = Vec::new();
+        let mut chars = instr.chars().peekable();
+        while let Some(&c) = chars.peek() {
+            if c.is_whitespace() {
+                chars.next();
+            } else if c == '"' {
+                chars.next();
+                let mut w = String::new();
+                while let Some(c) = chars.next() {
+                    match c {
+                        '"' => break,
+                        '\\' if matches!(chars.peek(), Some('"' | '\\')) => w.extend(chars.next()),
+                        c => w.push(c),
+                    }
+                }
+                words.push((w, true));
+            } else {
+                let mut w = String::new();
+                while let Some(&c) = chars.peek() {
+                    if c.is_whitespace() || (c == '"' && !w.is_empty()) {
+                        break;
+                    }
+                    w.push(c);
+                    chars.next();
+                }
+                words.push((w, false));
+            }
+        }
+        let mut words = words.into_iter().peekable();
+        let mut f =
+            FieldCode { name: words.next().map(|(w, _)| w.trim_start_matches('=').to_ascii_uppercase()).unwrap_or_default(), ..Default::default() };
+        while let Some((w, quoted)) = words.next() {
+            let sw = if quoted { None } else { w.strip_prefix('\\').and_then(|r| r.chars().next()) };
+            match sw {
+                Some(c) => {
+                    let arg = match words.peek() {
+                        Some((n, q)) if *q || !n.starts_with('\\') => words.next().map(|(n, _)| n),
+                        _ => None,
+                    };
+                    f.switches.push((c.to_ascii_lowercase(), arg));
+                }
+                None => f.args.push(w),
+            }
+        }
+        f
+    }
+
+    pub fn has(&self, c: char) -> bool {
+        self.switches.iter().any(|(k, _)| *k == c)
+    }
+
+    /// The argument of switch `c`, if the switch is there with one.
+    pub fn arg(&self, c: char) -> Option<&str> {
+        self.switches.iter().find(|(k, _)| *k == c).and_then(|(_, a)| a.as_deref())
+    }
+}
+
+/// A level range such as `1-3` (or one level, `2`), clamped to 1–9.
+pub fn level_range(s: &str) -> Option<(u8, u8)> {
+    let mut it = s.split('-').map(|x| x.trim().parse::<u8>().ok());
+    let a = it.next().flatten()?.clamp(1, 9);
+    let b = match it.next() {
+        Some(b) => b?.clamp(1, 9),
+        None => a,
+    };
+    Some((a.min(b), a.max(b)))
+}
+
+/// The tab leader named in a command parameter.
+pub fn leader(name: &str) -> TabLeader {
+    match name {
+        "none" => TabLeader::None,
+        "hyphen" => TabLeader::Hyphen,
+        "underscore" => TabLeader::Underscore,
+        "middleDot" => TabLeader::MiddleDot,
+        _ => TabLeader::Dot,
+    }
+}
+
+/// The TOC field instruction for `references.toc`'s parameters (ECMA-376 §17.16.5.68): `\o`
+/// heading styles, `\h` hyperlinks, `\z` hide tab and page numbers in Web view, `\u` outline
+/// levels, `\f`/`\l` TC fields, `\n` without page numbers, `\p` separator, `\t` styles with levels.
+pub fn toc_instr(v: &Value) -> String {
+    let levels = p::u64(v, "levels").unwrap_or(3).clamp(1, 9);
+    let on = |k: &str, d: bool| p::bool(v, k).unwrap_or(d);
+    let mut s = String::from("TOC");
+    if on("headingStyles", true) {
+        s.push_str(&format!(" \\o \"1-{levels}\""));
+    }
+    if on("hyperlinks", true) {
+        s.push_str(" \\h");
+    }
+    s.push_str(" \\z");
+    if on("outlineLevels", true) {
+        s.push_str(" \\u");
+    }
+    if on("tcFields", false) {
+        s.push_str(&format!(" \\f \\l \"1-{levels}\""));
+    }
+    if !on("pageNumbers", true) {
+        s.push_str(&format!(" \\n \"1-{levels}\""));
+    } else if !on("rightAlign", true) {
+        s.push_str(" \\p \" \"");
+    }
+    let clean = |n: &str| n.chars().filter(|c| !matches!(c, '"' | ',' | '\\')).take(64).collect::<String>().trim().to_string();
+    let pairs: Vec<String> = match v.get("styleLevels") {
+        Some(Value::Object(m)) => m
+            .iter()
+            .take(64)
+            .filter_map(|(name, l)| Some((clean(name), l.as_u64()?.clamp(1, 9))))
+            .filter(|(n, _)| !n.is_empty())
+            .map(|(n, l)| format!("{n},{l}"))
+            .collect(),
+        _ => Vec::new(),
+    };
+    if !pairs.is_empty() {
+        s.push_str(&format!(" \\t \"{}\"", pairs.join(",")));
+    }
+    s
+}
+
+/// A TOC entry: the paragraph it points at, its level (0-based), its text, and the leading page
+/// breaks of that paragraph (its page is where the text after them lands).
+struct TocEntry {
+    path: Path,
+    level: u8,
+    text: String,
+    lead: usize,
+}
+
+/// The heading level (1–9) of a built-in heading style.
+fn heading_style_level(p: &Paragraph) -> Option<u8> {
+    p.props.style.as_deref()?.strip_prefix("Heading")?.trim().parse::<u8>().ok().filter(|l| (1..=9).contains(l))
+}
+
+/// The entries a TOC field collects from the body, in document order: built-in heading styles
+/// in the `\o` range, paragraphs with an outline level (`\u`), styles listed in `\t`, and TC
+/// fields (`\f`, levels `\l`).
+fn toc_entries(s: &Session, f: &FieldCode) -> Vec<TocEntry> {
+    let o = f.has('o').then(|| f.arg('o').and_then(level_range).unwrap_or((1, 9)));
+    let max = o.map(|r| r.1).unwrap_or(9);
+    let styles: Vec<(String, u8)> = f
+        .arg('t')
+        .map(|t| {
+            let parts: Vec<&str> = t.split([',', ';']).map(str::trim).collect();
+            parts.chunks(2).filter_map(|c| Some((c.first()?.to_string(), c.get(1)?.parse::<u8>().ok()?.clamp(1, 9)))).collect()
+        })
+        .unwrap_or_default();
+    let tc = f.has('f').then(|| f.arg('f').unwrap_or("").to_ascii_uppercase());
+    let tc_levels = f.arg('l').and_then(level_range).unwrap_or((1, 9));
     let mut v = Vec::new();
     for path in s.doc.para_paths(StoryRef::Body) {
         if path.depth() > 0 {
@@ -90,26 +253,51 @@ fn headings(s: &Session, levels: u8) -> Vec<(Path, u8, String)> {
         if style.starts_with("TOC") {
             continue;
         }
-        let rp = s.doc.styles.resolve_para(&p.props);
-        if let Some(l) = rp.outline_level
-            && l < levels
-        {
+        let lead = p.text.bytes().take_while(|b| *b == 0x0C).count();
+        let by_style =
+            styles.iter().find(|(n, _)| s.doc.styles.get(style).is_some_and(|st| st.name.eq_ignore_ascii_case(n)) || n == style).map(|(_, l)| *l);
+        // `Some(9)` direct outline level is body text: "Do Not Show in Table of Contents".
+        let by_outline = f.has('u').then_some(p.props.outline_level).flatten().filter(|l| *l < 9).map(|l| l + 1).filter(|l| *l <= max);
+        let hidden = f.has('u') && p.props.outline_level == Some(9);
+        let by_heading = o.and_then(|(a, b)| {
+            let l = heading_style_level(p).or_else(|| {
+                s.doc
+                    .styles
+                    .resolve_para(&wordcraft_doc::ParaProps { style: p.props.style.clone(), ..Default::default() })
+                    .outline_level
+                    .map(|l| l + 1)
+            })?;
+            (a..=b).contains(&l).then_some(l)
+        });
+        if let Some(l) = by_style.or(by_outline).or(if hidden { None } else { by_heading }) {
             let t = p.plain_text().replace(['\u{000C}', '\n', '\t'], " ").trim().to_string();
             if !t.is_empty() {
-                v.push((path, l, t));
+                v.push(TocEntry { path: path.clone(), level: l - 1, text: t, lead });
+            }
+        }
+        if let Some(id) = &tc {
+            for off in p.object_offsets() {
+                let Some(InlineObject::Field { instr, .. }) = p.object_at(off) else { continue };
+                let c = FieldCode::parse(instr);
+                if c.name != "TC" {
+                    continue;
+                }
+                let kind = c.arg('f').unwrap_or("C").to_ascii_uppercase();
+                let l = c.arg('l').and_then(|l| l.trim().parse::<u8>().ok()).unwrap_or(1).clamp(1, 9);
+                let text = c.args.first().map(|t| t.trim().to_string()).unwrap_or_default();
+                if (id.is_empty() || *id == kind) && (tc_levels.0..=tc_levels.1).contains(&l) && !text.is_empty() {
+                    v.push(TocEntry { path: path.clone(), level: l - 1, text, lead: off });
+                }
             }
         }
     }
     v
 }
 
-/// The TOC block range in the body: the paragraph holding the TOC field and the TOC entries after it.
+/// The TOC block range in the body: the paragraph holding the TOC field and the TOC entries after
+/// it. A TOC with `\c` is a table of figures, kept by the generated lists.
 fn toc_range(s: &Session) -> Option<(usize, usize)> {
-    let start = s.doc.body.iter().position(|b| {
-        b.as_para().is_some_and(|p| {
-            p.objects.iter().any(|o| matches!(o, InlineObject::Field { instr, .. } if instr.trim_start().to_ascii_uppercase().starts_with("TOC")))
-        })
-    })?;
+    let start = s.doc.body.iter().position(|b| b.as_para().is_some_and(|p| toc_field(p).is_some()))?;
     let mut end = start;
     while let Some(Block::Para(p)) = s.doc.body.get(end + 1).map(|b| &**b) {
         if p.props.style.as_deref().is_some_and(|st| st.starts_with("TOC") && st != "TOCHeading") {
@@ -121,33 +309,39 @@ fn toc_range(s: &Session) -> Option<(usize, usize)> {
     Some((start, end))
 }
 
-fn toc_levels(s: &Session, start: usize) -> u8 {
-    s.doc
-        .body
-        .get(start)
-        .and_then(|b| b.as_para())
-        .and_then(|p| {
-            p.objects.iter().find_map(|o| match o {
-                InlineObject::Field { instr, .. } => instr
-                    .split("\\o")
-                    .nth(1)
-                    .and_then(|r| r.trim().trim_matches('"').split('-').nth(1))
-                    .and_then(|n| n.trim_matches('"').parse::<u8>().ok()),
-                _ => None,
-            })
-        })
-        .unwrap_or(3)
-        .clamp(1, 9)
+/// The TOC field instruction in `p` (not a table of figures).
+fn toc_field(p: &Paragraph) -> Option<String> {
+    p.objects.iter().find_map(|o| match o {
+        InlineObject::Field { instr, .. } => {
+            let f = FieldCode::parse(instr);
+            (f.name == "TOC" && !f.has('c')).then(|| instr.clone())
+        }
+        _ => None,
+    })
 }
 
 fn insert_toc(s: &mut Session, v: &Value) -> CmdResult {
-    if toc_range(s).is_some() {
-        update_toc(s)?;
-        return sel_result(s);
-    }
-    let levels = p::u64(v, "levels").unwrap_or(3).clamp(1, 9) as u8;
+    let replace = v.as_object().is_some_and(|m| !m.is_empty());
+    // Replacing a table puts the new one where the old one was, in place of an empty paragraph.
+    let mut placeholder = false;
+    let at = match toc_range(s) {
+        // `{}` updates the table there; settings replace it where it is.
+        Some(_) if !replace => {
+            update_toc(s)?;
+            return sel_result(s);
+        }
+        Some((start, end)) => {
+            for i in (start..=end).rev() {
+                s.doc.remove_block(StoryRef::Body, &Path::top(i))?;
+            }
+            s.doc.insert_block(StoryRef::Body, &Path::top(start), Block::Para(Paragraph::new()))?;
+            placeholder = true;
+            s.sel = Selection::caret(Pos { story: StoryRef::Body, path: Path::top(start), off: 0 });
+            s.sel.focus.clone()
+        }
+        None => delete_selection(s)?,
+    };
     let title = p::str(v, "title").unwrap_or("Contents").to_string();
-    let at = delete_selection(s)?;
     if at.story != StoryRef::Body || at.path.depth() > 0 {
         return Err(CmdError::Failed("a table of contents goes in the main text".into()));
     }
@@ -155,28 +349,95 @@ fn insert_toc(s: &mut Session, v: &Value) -> CmdResult {
     let mut head = Paragraph::with_text(&title, CharProps::default()).styled("TOCHeading");
     head.insert_object(
         head.len(),
-        InlineObject::Field { instr: format!("TOC \\o \"1-{levels}\" \\h \\z \\u"), result: String::new(), locked: false, code: false },
+        InlineObject::Field { instr: toc_instr(v), result: String::new(), locked: false, code: false },
         &CharProps::default(),
     )?;
-    let i = if s.doc.para_at(&at).is_some_and(|p| p.is_empty()) { at.path.last() } else { s.doc.split_paragraph(&at)?.path.last() };
+    let i = if s.doc.para_at(&at).is_some_and(|p| p.is_empty()) {
+        if placeholder {
+            s.doc.remove_block(StoryRef::Body, &at.path)?;
+        }
+        at.path.last()
+    } else {
+        s.doc.split_paragraph(&at)?.path.last()
+    };
     s.doc.insert_block(StoryRef::Body, &Path::top(i), Block::Para(head))?;
-    update_toc(s)?;
+    let leader = leader(p::str(v, "tabLeader").unwrap_or("dot"));
+    regenerate_toc(s, Some(leader))?;
+    s.clamp_selection();
     sel_result(s)
 }
 
+/// A hidden `_Toc` bookmark around the heading at body block `i` (after its leading page breaks),
+/// reusing one already there; its name.
+fn toc_bookmark(s: &mut Session, i: usize, lead: usize) -> Result<String, CmdError> {
+    const MARK: usize = wordcraft_doc::para::OBJ.len_utf8();
+    let para = s.doc.para(StoryRef::Body, &Path::top(i)).ok_or_else(|| CmdError::Failed("heading is gone".into()))?;
+    if let Some(InlineObject::BookmarkStart { name }) = para.object_at(lead)
+        && name.starts_with("_Toc")
+    {
+        return Ok(name.clone());
+    }
+    let next =
+        s.doc.bookmarks().iter().filter_map(|(n, _)| n.strip_prefix("_Toc").and_then(|d| d.parse::<u64>().ok())).max().unwrap_or(0).saturating_add(1);
+    let name = format!("_Toc{next:09}");
+    let end = para.len();
+    let props = CharProps::default();
+    let pos = |off| Pos { story: StoryRef::Body, path: Path::top(i), off };
+    s.doc.insert_object(&pos(end), InlineObject::BookmarkEnd { name: name.clone() }, &props)?;
+    s.doc.insert_object(&pos(lead), InlineObject::BookmarkStart { name: name.clone() }, &props)?;
+    // The caret in that paragraph stays on the same text.
+    let shift = |p: &mut Pos| {
+        if p.story == StoryRef::Body && p.path == Path::top(i) {
+            if p.off > end {
+                p.off = p.off.saturating_add(2 * MARK);
+            } else if p.off >= lead && p.off > 0 {
+                p.off = p.off.saturating_add(MARK);
+            }
+        }
+    };
+    shift(&mut s.sel.anchor);
+    shift(&mut s.sel.focus);
+    Ok(name)
+}
+
 /// Regenerate the TOC entries with page numbers (two layout passes: entries change pagination).
 pub fn update_toc(s: &mut Session) -> Result<(), CmdError> {
+    regenerate_toc(s, None)
+}
+
+/// Rebuild the entries the TOC field's switches ask for. The tab leader is `leader`, or the one
+/// the entries had (Word keeps it in the entries' tab stops, not in the field).
+fn regenerate_toc(s: &mut Session, leader: Option<TabLeader>) -> Result<(), CmdError> {
     let Some((start, end)) = toc_range(s) else { return Ok(()) };
-    let levels = toc_levels(s, start);
+    let Some(instr) = s.doc.body.get(start).and_then(|b| b.as_para()).and_then(toc_field) else { return Ok(()) };
+    let f = FieldCode::parse(&instr);
+    let leader = leader.unwrap_or_else(|| {
+        s.doc
+            .body
+            .get(start + 1)
+            .filter(|_| end > start)
+            .and_then(|b| b.as_para())
+            .and_then(|p| p.props.tabs.as_ref()?.last().map(|t| t.leader))
+            .unwrap_or(TabLeader::Dot)
+    });
     for i in (start + 1..=end).rev() {
         s.doc.remove_block(StoryRef::Body, &Path::top(i))?;
     }
     let width = super::page::sect(s).text_width();
-    let entries = headings(s, levels);
-    // A heading typed after a manual page break starts with that break; its page is where the
-    // text after the break lands, so look the page up past any leading breaks.
-    let leads: Vec<usize> =
-        entries.iter().map(|(path, ..)| s.doc.para(StoryRef::Body, path).map_or(0, |p| p.text.bytes().take_while(|b| *b == 0x0C).count())).collect();
+    let entries = toc_entries(s, &f);
+    let links: Vec<Option<String>> = if f.has('h') {
+        let mut v = Vec::new();
+        for e in &entries {
+            // TC fields link to their paragraph's start.
+            let lead = s.doc.para(StoryRef::Body, &e.path).map_or(0, |p| p.text.bytes().take_while(|b| *b == 0x0C).count());
+            v.push(Some(format!("#{}", toc_bookmark(s, e.path.last(), lead)?)));
+        }
+        v
+    } else {
+        vec![None; entries.len()]
+    };
+    let no_pages = f.has('n').then(|| f.arg('n').and_then(level_range).unwrap_or((1, 9)));
+    let sep = f.arg('p').map(str::to_string).unwrap_or_else(|| "\t".into());
     for pass in 0..2 {
         // Pass 1 lays out with the entries in place, so headings below the TOC sit `entries.len()`
         // blocks further down and their pages account for the TOC's own length.
@@ -189,12 +450,18 @@ pub fn update_toc(s: &mut Session) -> Result<(), CmdError> {
             }
         }
         let shift = if pass == 0 { 0 } else { entries.len() };
-        for (k, (path, level, text)) in entries.iter().enumerate() {
-            let target = Path::top(path.last() + if path.last() > start { shift } else { 0 });
-            let off = leads.get(k).copied().unwrap_or(0);
-            let page = l.caret(&Pos { story: StoryRef::Body, path: target, off }).and_then(|c| l.pages.get(c.page)).map(|pg| pg.number).unwrap_or(1);
-            let mut para = Paragraph::with_text(&format!("{text}\t{page}"), CharProps::default()).styled(&format!("TOC{}", level + 1));
-            para.props.tabs = Some(vec![TabStop { pos: width - 0.5, align: TabAlign::Right, leader: TabLeader::Dot }]);
+        for (k, e) in entries.iter().enumerate() {
+            let target = Path::top(e.path.last() + if e.path.last() > start { shift } else { 0 });
+            let page =
+                l.caret(&Pos { story: StoryRef::Body, path: target, off: e.lead }).and_then(|c| l.pages.get(c.page)).map(|pg| pg.number).unwrap_or(1);
+            let show_page = no_pages.is_none_or(|(a, b)| !(a..=b).contains(&(e.level + 1)));
+            let text = if show_page { format!("{}{sep}{page}", e.text) } else { e.text.clone() };
+            let props = CharProps { link: links.get(k).cloned().flatten(), ..Default::default() };
+            let mut para = Paragraph::with_text(&text, props).styled(&format!("TOC{}", e.level + 1));
+            para.mark = CharProps::default();
+            if show_page && sep.contains('\t') {
+                para.props.tabs = Some(vec![TabStop { pos: width - 0.5, align: TabAlign::Right, leader }]);
+            }
             s.doc.insert_block(StoryRef::Body, &Path::top(start + 1 + k), Block::Para(para))?;
         }
     }
@@ -337,45 +604,152 @@ fn note_refs(s: &Session) -> Vec<Pos> {
     v
 }
 
-fn caption(s: &mut Session, v: &Value) -> CmdResult {
-    let label = p::str(v, "label").unwrap_or("Figure").to_string();
-    let text = p::str(v, "text").unwrap_or("").to_string();
-    // Number = existing captions with this label before the caret + 1.
-    let caret = s.sel.focus.clone();
-    let n = s
-        .doc
-        .para_paths(StoryRef::Body)
-        .into_iter()
-        .filter(|q| *q < caret.path)
-        .filter(|q| s.doc.para(StoryRef::Body, q).is_some_and(|p| p.props.style.as_deref() == Some("Caption") && p.text.starts_with(&label)))
-        .count()
-        + 1;
-    let f = s.sel.focus.clone();
-    let len = s.doc.para_at(&f).map(|p| p.len()).unwrap_or(0);
-    let at = Pos { off: len, ..f };
-    let new = s.doc.split_paragraph(&at)?;
-    let para = s.doc.para_mut(new.story, &new.path)?;
-    para.props = wordcraft_doc::ParaProps { style: Some("Caption".into()), ..Default::default() };
-    para.mark = CharProps::default();
-    let base = format!("{label} ");
-    para.insert_text(0, &base, &CharProps::default())?;
-    para.insert_object(
-        base.len(),
-        InlineObject::Field { instr: format!("SEQ {label} \\* ARABIC"), result: n.to_string(), locked: false, code: false },
-        &CharProps::default(),
-    )?;
-    let end = para.len();
-    if !text.is_empty() {
-        para.insert_text(end, &format!(": {text}"), &CharProps::default())?;
+/// The `\*` format switch value for a caption's number format (OOXML names work too).
+pub fn seq_format(name: &str) -> &'static str {
+    match name {
+        "alphabetic" | "lowerLetter" => "alphabetic",
+        "ALPHABETIC" | "upperLetter" => "ALPHABETIC",
+        "roman" | "lowerRoman" => "roman",
+        "ROMAN" | "upperRoman" => "ROMAN",
+        _ => "ARABIC",
     }
-    let off = para.len();
-    s.sel = Selection::caret(Pos { off, ..new });
+}
+
+/// Separators Word offers between a chapter number and a caption number.
+pub const CHAPTER_SEPARATORS: [&str; 5] = ["-", ".", ":", "\u{2014}", "\u{2013}"];
+
+/// Insert a caption paragraph below (or above) the caret's paragraph, table or object: the label,
+/// a chapter number (`STYLEREF n \s` and a separator) and a `SEQ label \* format \s n` number
+/// (ECMA-376 §17.16.5.56, §17.16.5.59).
+fn caption(s: &mut Session, v: &Value) -> CmdResult {
+    let label: String = p::str(v, "label").unwrap_or("Figure").chars().filter(|c| !matches!(c, '"' | '\\') && !c.is_control()).take(40).collect();
+    let label = if label.trim().is_empty() { "Figure".to_string() } else { label.trim().to_string() };
+    // SEQ identifiers are one word: Word joins a multi-word label with underscores.
+    let ident = label.split_whitespace().collect::<Vec<_>>().join("_");
+    let text = p::str(v, "text").unwrap_or("").to_string();
+    let above = p::str(v, "position") == Some("above");
+    let format = seq_format(p::str(v, "format").unwrap_or("ARABIC"));
+    let chapter = p::u64(v, "chapter").filter(|l| (1..=9).contains(l));
+    let sep = p::str(v, "separator").and_then(|x| CHAPTER_SEPARATORS.iter().find(|s| **s == x)).copied().unwrap_or("-");
+    let mut para = Paragraph::new().styled("Caption");
+    let field = |instr: String| InlineObject::Field { instr, result: String::new(), locked: false, code: false };
+    if !p::bool(v, "excludeLabel").unwrap_or(false) {
+        para.insert_text(0, &format!("{label} "), &CharProps::default())?;
+    }
+    let mut seq = format!("SEQ {ident} \\* {format}");
+    if let Some(l) = chapter {
+        para.insert_object(para.len(), field(format!("STYLEREF {l} \\s")), &CharProps::default())?;
+        para.insert_text(para.len(), sep, &CharProps::default())?;
+        seq.push_str(&format!(" \\s {l}"));
+    }
+    para.insert_object(para.len(), field(seq), &CharProps::default())?;
+    if !text.is_empty() {
+        para.insert_text(para.len(), &format!(": {text}"), &CharProps::default())?;
+    }
+    // Next to the caret's top-level block: a paragraph, or the whole table it is in.
+    let f = s.sel.focus.clone();
+    let top = f.path.0.first().copied().unwrap_or(0) as usize;
+    let i = if above { top } else { top.saturating_add(1) };
+    s.doc.insert_block(f.story, &Path::top(i), Block::Para(para))?;
+    update_seq(s)?;
+    let off = s.doc.para(f.story, &Path::top(i)).map_or(0, |p| p.len());
+    s.sel = Selection::caret(Pos { story: f.story, path: Path::top(i), off });
     sel_result(s)
 }
 
+/// The number part of a heading's list label (`Chapter 2.` → `2`).
+fn chapter_number(label: &str) -> String {
+    let word = label.split_whitespace().last().unwrap_or("");
+    word.trim_matches(|c: char| !c.is_alphanumeric()).to_string()
+}
+
+/// Renumber the body's SEQ fields in document order, honouring `\* format`, `\s level` (restart
+/// after each heading of that level), `\r n` (reset to n), `\c` (repeat) and `\h` (hide), and
+/// fill chapter-number `STYLEREF n \s` fields with the last level-n heading's number (its list
+/// label, or its count when the heading isn't numbered).
+pub fn update_seq(s: &mut Session) -> Result<(), CmdError> {
+    let mut counters = wordcraft_doc::numbering::Counters::default();
+    let mut headings = [0u32; 9];
+    let mut chapter: [String; 9] = Default::default();
+    let mut heading_text: [String; 9] = Default::default();
+    let mut seq: std::collections::HashMap<String, (u32, u32)> = Default::default();
+    for path in s.doc.para_paths(StoryRef::Body) {
+        let Some(p) = s.doc.para(StoryRef::Body, &path) else { continue };
+        let label = p
+            .props
+            .numbering
+            .or_else(|| s.doc.styles.resolve_para(&p.props).numbering)
+            .filter(|n| n.num != 0)
+            .and_then(|n| counters.next_label(&s.doc.numbering, n.num, n.level))
+            .map(|(l, _)| l);
+        if let Some(l) = heading_style_level(p)
+            && let Some(k) = (l as usize).checked_sub(1)
+            && let Some(count) = headings.get_mut(k)
+        {
+            *count = count.saturating_add(1);
+            let n = label.map(|l| chapter_number(&l)).filter(|n| !n.is_empty()).unwrap_or_else(|| count.to_string());
+            if let Some(c) = chapter.get_mut(k) {
+                *c = n;
+            }
+            if let Some(t) = heading_text.get_mut(k) {
+                *t = p.plain_text().trim().to_string();
+            }
+        }
+        let mut updates: Vec<(usize, String)> = Vec::new();
+        for (k, o) in p.objects.iter().enumerate() {
+            let InlineObject::Field { instr, locked: false, .. } = o else { continue };
+            let f = FieldCode::parse(instr);
+            match f.name.as_str() {
+                "SEQ" => {
+                    let Some(id) = f.args.first() else { continue };
+                    let restart =
+                        f.arg('s').and_then(|l| l.parse::<usize>().ok()).and_then(|l| l.checked_sub(1)).and_then(|l| headings.get(l)).copied();
+                    let n = seq.entry(id.clone()).or_insert((0, 0));
+                    if let Some(epoch) = restart
+                        && n.1 != epoch
+                    {
+                        *n = (0, epoch);
+                    }
+                    if let Some(r) = f.arg('r').and_then(|r| r.parse::<u32>().ok()) {
+                        n.0 = r;
+                    } else if !f.has('c') {
+                        n.0 = n.0.saturating_add(1);
+                    }
+                    let fmt = wordcraft_layout::fields::format_switch(instr).unwrap_or_default();
+                    updates.push((k, if f.has('h') { String::new() } else { fmt.format(n.0) }));
+                }
+                "STYLEREF" => {
+                    let level = f
+                        .args
+                        .first()
+                        .and_then(|a| a.strip_prefix("Heading").unwrap_or(a).trim().parse::<usize>().ok())
+                        .and_then(|l| l.checked_sub(1));
+                    let Some(level) = level else { continue };
+                    let r = if f.has('s') || f.has('n') { chapter.get(level) } else { heading_text.get(level) };
+                    if let Some(r) = r {
+                        updates.push((k, r.clone()));
+                    }
+                }
+                _ => {}
+            }
+        }
+        if updates.is_empty() {
+            continue;
+        }
+        let para = s.doc.para_mut(StoryRef::Body, &path)?;
+        for (k, r) in updates {
+            if let Some(InlineObject::Field { result, .. }) = para.objects.get_mut(k) {
+                *result = r;
+            }
+        }
+        para.touch();
+    }
+    Ok(())
+}
+
 /// Update fields in the body: dates, SEQ numbering, cross-references, TOC.
 pub fn update_fields(s: &mut Session) -> Result<(), CmdError> {
-    let mut seq: std::collections::HashMap<String, u32> = Default::default();
+    update_seq(s)?;
     let mut pages: std::collections::HashMap<String, u32> = Default::default();
     for (name, pos) in s.doc.bookmarks() {
         let l = s.layout();
@@ -396,12 +770,6 @@ pub fn update_fields(s: &mut Session) -> Result<(), CmdError> {
                     let pic = date_picture(instr).unwrap_or_else(|| if name == "TIME" { "h:mm am/pm".into() } else { "M/d/yyyy".into() });
                     updates.push((k, super::insert::format_date(&pic)));
                 }
-                "SEQ" => {
-                    let id = instr.split_whitespace().nth(1).unwrap_or("").to_string();
-                    let n = seq.entry(id).or_insert(0);
-                    *n += 1;
-                    updates.push((k, n.to_string()));
-                }
                 "REF" | "PAGEREF" => {
                     let target = instr.split_whitespace().nth(1).unwrap_or("");
                     let r = if name == "REF" { bookmark_text(&s.doc, target) } else { pages.get(target).map(u32::to_string) };
@@ -452,3 +820,83 @@ pub fn bookmark_text(doc: &wordcraft_doc::Document, name: &str) -> Option<String
         .unwrap_or(para.len());
     Some(doc.copy_range(&start, &Pos { off: end, ..start.clone() }).plain_text().trim().to_string())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn fields(s: &Session) -> Vec<(String, String)> {
+        let mut out = Vec::new();
+        for path in s.doc.para_paths(StoryRef::Body) {
+            for o in &s.doc.para(StoryRef::Body, &path).unwrap().objects {
+                if let InlineObject::Field { instr, result, .. } = o {
+                    out.push((instr.clone(), result.clone()));
+                }
+            }
+        }
+        out
+    }
+
+    /// #402: Custom Table of Contents settings become TOC switches, and updating honours them:
+    /// levels (`\o`), a style with a level (`\t`), no hyperlinks, page numbers after a space
+    /// (`\p`), or none at all (`\n`).
+    #[test]
+    fn toc_switches_shape_the_entries() {
+        let mut s = Session::new(wordcraft_doc::Document::from_text("Intro\nPart\nDeep\nNote"));
+        for (text, style) in [("Intro", "Heading 1"), ("Part", "Heading 2"), ("Deep", "Heading 3"), ("Note", "Quote")] {
+            s.run("select.text", &json!({"text": text})).unwrap();
+            s.run("styles.apply", &json!({"style": style})).unwrap();
+        }
+        s.run("caret.docStart", &json!({})).unwrap();
+        s.run("references.toc", &json!({"levels": 2, "hyperlinks": false, "rightAlign": false, "styleLevels": {"Quote": 2}})).unwrap();
+        assert_eq!(fields(&s)[0].0, "TOC \\o \"1-2\" \\z \\u \\p \" \" \\t \"Quote,2\"");
+        let entries: Vec<(String, String)> = s
+            .doc
+            .body
+            .iter()
+            .filter_map(|b| b.as_para())
+            .filter(|p| p.props.style.as_deref().is_some_and(|st| st.starts_with("TOC") && st != "TOCHeading"))
+            .map(|p| (p.props.style.clone().unwrap(), p.plain_text()))
+            .collect();
+        assert_eq!(entries, [("TOC1", "Intro 1"), ("TOC2", "Part 1"), ("TOC2", "Note 1")].map(|(a, b)| (a.to_string(), b.to_string())));
+        assert!(s.doc.bookmarks().is_empty(), "no hyperlinks, no _Toc bookmarks");
+        // Settings again replace the table in place; hyperlinks bookmark the headings.
+        s.run("references.toc", &json!({"levels": 3, "pageNumbers": false})).unwrap();
+        assert_eq!(s.doc.plain_text(StoryRef::Body).matches("Contents").count(), 1);
+        let toc: Vec<String> =
+            s.doc.body.iter().filter_map(|b| b.as_para()).filter(|p| p.props.style.as_deref() == Some("TOC3")).map(|p| p.plain_text()).collect();
+        assert_eq!(toc, ["Deep"]);
+        let first = s.doc.body.iter().filter_map(|b| b.as_para()).find(|p| p.props.style.as_deref() == Some("TOC1")).unwrap();
+        let link = first.runs[0].props.link.clone().unwrap();
+        assert!(s.doc.bookmarks().iter().any(|(n, _)| format!("#{n}") == link), "{link}");
+    }
+
+    /// #402: Caption numbering — a custom label above the paragraph, letters, and chapter
+    /// numbers that restart after each Heading 1 (`STYLEREF 1 \s`, `SEQ … \s 1`).
+    #[test]
+    fn caption_numbering_with_chapters() {
+        let mut s = Session::new(wordcraft_doc::Document::from_text("One\nPic\nPic two\nTwo\nPic three"));
+        for t in ["One", "Two"] {
+            s.run("select.text", &json!({"text": t})).unwrap();
+            s.run("styles.apply", &json!({"style": "Heading 1"})).unwrap();
+        }
+        let opts = json!({"label": "Photo Plate", "format": "upperLetter", "chapter": 1, "separator": "."});
+        for t in ["Pic three", "Pic two", "Pic"] {
+            s.run("select.text", &json!({"text": t})).unwrap();
+            let mut v = opts.clone();
+            v["position"] = json!("above");
+            v["text"] = json!(t);
+            s.run("references.caption", &v).unwrap();
+        }
+        let caps: Vec<String> =
+            s.doc.body.iter().filter_map(|b| b.as_para()).filter(|p| p.props.style.as_deref() == Some("Caption")).map(|p| p.plain_text()).collect();
+        assert_eq!(caps, ["Photo Plate 1.A: Pic", "Photo Plate 1.B: Pic two", "Photo Plate 2.A: Pic three"]);
+        assert!(fields(&s).contains(&("SEQ Photo_Plate \\* ALPHABETIC \\s 1".to_string(), "A".to_string())), "{:?}", fields(&s));
+        // The caption sits above its paragraph; excluding the label leaves the number.
+        let i = s.doc.body.iter().position(|b| b.as_para().is_some_and(|p| p.plain_text() == "Pic")).unwrap();
+        assert_eq!(s.doc.body[i - 1].as_para().unwrap().plain_text(), "Photo Plate 1.A: Pic");
+        s.run("caret.docEnd", &json!({})).unwrap();
+        s.run("references.caption", &json!({"label": "Table", "excludeLabel": true, "format": "ROMAN"})).unwrap();
+        assert_eq!(s.doc.body.last().unwrap().as_para().unwrap().plain_text(), "I");
+    }
+}
diff --git a/crates/engine/src/cmd/review.rs b/crates/engine/src/cmd/review.rs
index af72d2630c..228f45fa4b 100644
--- a/crates/engine/src/cmd/review.rs
+++ b/crates/engine/src/cmd/review.rs
@@ -120,7 +120,7 @@ fn new_comment(s: &mut Session, v: &Value) -> CmdResult {
     };
     let part = s.doc.add_part(PartKind::Comment, vec![para_block(Paragraph::with_text(&text, Default::default()))]);
     let id = s.doc.comments.keys().next_back().map(|k| k + 1).unwrap_or(0);
-    let initials: String = s.author.split_whitespace().filter_map(|w| w.chars().next()).collect();
+    let initials = s.user_initials();
     s.doc.comments.insert(id, Comment { author: s.author.clone(), initials, date: now_iso(), parent: None, resolved: false, part });
     let props = Default::default();
     s.doc.insert_object(&b, InlineObject::CommentEnd { id }, &props)?;
@@ -137,7 +137,7 @@ fn reply(s: &mut Session, v: &Value) -> CmdResult {
     let text = p::req_str(v, "text")?;
     let part = s.doc.add_part(PartKind::Comment, vec![para_block(Paragraph::with_text(text, Default::default()))]);
     let id = s.doc.comments.keys().next_back().map(|k| k + 1).unwrap_or(0);
-    let initials: String = s.author.split_whitespace().filter_map(|w| w.chars().next()).collect();
+    let initials = s.user_initials();
     s.doc.comments.insert(id, Comment { author: s.author.clone(), initials, date: now_iso(), parent: Some(parent), resolved: false, part });
     Ok(json!({"id": id}))
 }
@@ -576,6 +576,90 @@ pub fn has_format_changes(doc: &wordcraft_doc::Document) -> bool {
     })
 }
 
+/// A tracked deletion in the body shown in a balloon (Show revisions in balloons).
+#[derive(Clone, Debug, PartialEq)]
+pub struct DeletionBalloon {
+    /// Where the deleted text was: the balloon's anchor.
+    pub at: Pos,
+    pub author: String,
+    /// The deleted text, a deleted paragraph mark as ¶, shortened to [`DELETION_TEXT_CHARS`].
+    pub text: String,
+}
+
+/// At most this many characters of deleted text show in a balloon (a deleted page shows its start).
+pub const DELETION_TEXT_CHARS: usize = 200;
+/// At most this many deletion balloons (a document of many small deletions can't flood the area).
+const MAX_DELETION_BALLOONS: usize = 500;
+
+/// The tracked deletions in the body, for balloons, in document order. Deleted text running on
+/// across runs, revisions and paragraph marks by the same author is one balloon. The source of a
+/// move is left out: it has its "Moved from" balloon ([`move_changes`]).
+pub fn deletion_balloons(s: &Session) -> Vec<DeletionBalloon> {
+    let doc = &s.doc;
+    let author = |rev: u32| doc.revisions.get(rev as usize).map(|r| r.author.clone()).unwrap_or_default();
+    let mk = |path: &wordcraft_doc::Path, off| Pos { story: StoryRef::Body, path: path.clone(), off };
+    let mut out = Vec::new();
+    for path in doc.para_paths(StoryRef::Body) {
+        let Some(p) = doc.para(StoryRef::Body, &path) else { continue };
+        for (r, c) in p.run_ranges() {
+            // Inserted and then deleted text is a deletion (it's drawn and left out as one).
+            let Some(rev) = plain_deletion(doc, c.del) else { continue };
+            push_deletion(&mut out, mk(&path, r.start), mk(&path, r.end), author(rev), p.text.get(r).unwrap_or(""));
+        }
+        if let Some(rev) = plain_deletion(doc, p.mark.del) {
+            let at = mk(&path, p.len());
+            let next = path.with_last(path.last().saturating_add(1));
+            let end = if super::has_next_para(s, StoryRef::Body, &path) { mk(&next, 0) } else { at.clone() };
+            push_deletion(&mut out, at, end, author(rev), "¶");
+        }
+    }
+    out.into_iter().map(|(d, _, _)| d).collect()
+}
+
+/// Add `author`'s deleted `text` (from `at` to `end`) to `out`: to the last balloon when that
+/// deletion ends at `at` and is theirs, else as a new one. Each balloon carries where its deletion
+/// ends and how many characters its text has.
+fn push_deletion(out: &mut Vec<(DeletionBalloon, Pos, usize)>, at: Pos, end: Pos, author: String, text: &str) {
+    let joins = out.last().is_some_and(|(d, e, _)| *e == at && d.author == author);
+    if !joins {
+        if out.len() >= MAX_DELETION_BALLOONS {
+            return;
+        }
+        out.push((DeletionBalloon { at, author, text: String::new() }, end.clone(), 0));
+    }
+    let Some((d, e, chars)) = out.last_mut() else { return };
+    *e = end;
+    for c in text.chars() {
+        if *chars > DELETION_TEXT_CHARS {
+            break;
+        }
+        let c = match c {
+            // Pictures, fields and other objects show no text of their own.
+            wordcraft_doc::para::OBJ => continue,
+            '\t' | wordcraft_doc::para::LINE_BREAK | wordcraft_doc::para::PAGE_BREAK | wordcraft_doc::para::COLUMN_BREAK => ' ',
+            c if c.is_control() => continue,
+            c => c,
+        };
+        *chars += 1;
+        d.text.push(if *chars > DELETION_TEXT_CHARS { '…' } else { c });
+    }
+}
+
+/// A deletion revision that is not the source of a move (`w:moveFrom` is a deletion revision
+/// with a move name).
+fn plain_deletion(doc: &wordcraft_doc::Document, del: Option<u32>) -> Option<u32> {
+    del.filter(|_| doc.move_name(del).is_none())
+}
+
+/// Whether the body has any tracked deletion other than a move's source (cheap: stops at the
+/// first).
+pub fn has_deletions(doc: &wordcraft_doc::Document) -> bool {
+    doc.para_paths(StoryRef::Body).iter().any(|path| {
+        doc.para(StoryRef::Body, path)
+            .is_some_and(|p| plain_deletion(doc, p.mark.del).is_some() || p.runs.iter().any(|r| plain_deletion(doc, r.props.del).is_some()))
+    })
+}
+
 fn nav_change(s: &mut Session, dir: i32) -> CmdResult {
     let list = changes(s);
     let caret = s.sel.ordered();
@@ -659,7 +743,7 @@ fn word_count(s: &mut Session, v: &Value) -> CmdResult {
 fn para_issues(s: &Session, story: StoryRef, path: &wordcraft_doc::Path) -> Vec<(Pos, Pos, wordcraft_proof::Issue)> {
     let Some(p) = s.doc.para(story, path) else { return Vec::new() };
     let runs = wordcraft_layout::para::proof_runs(&s.doc, p, None);
-    wordcraft_layout::para::paragraph_issues(p, &runs)
+    wordcraft_layout::para::paragraph_issues(p, &runs, &s.prefs.spelling(), true)
         .into_iter()
         .map(|i| (Pos { story, path: path.clone(), off: i.start }, Pos { story, path: path.clone(), off: i.end }, i))
         .collect()
@@ -901,6 +985,183 @@ mod tests {
         assert_eq!(s.run("review.trackingOptions", &json!({})).unwrap()["insertColor"], "00AA00");
     }
 
+    fn glyph_text(d: &[Draw]) -> String {
+        d.iter().filter_map(|x| if let Draw::Glyphs { text, .. } = x { Some(text.as_str()) } else { None }).collect()
+    }
+
+    /// Show revisions in balloons: a tracked deletion leaves the text for a balloon at its place
+    /// and keeps its change bar; it comes back inline in the other modes and wherever no balloons
+    /// are shown (here the Comments pane, which changes the view without a relayout call).
+    #[test]
+    fn revisions_in_balloons_take_deletions_out_of_the_text() {
+        use super::{DeletionBalloon, deletion_balloons};
+        let mut s = Session::new(Document::new());
+        s.view.proofing = false;
+        s.author = "Ana".into();
+        s.run("document.setText", &json!({"text": "keep gone stay"})).unwrap();
+        s.run("review.trackChanges", &json!({"value": true})).unwrap();
+        s.run("select.range", &json!({"anchor": {"block": 0, "off": 5}, "focus": {"block": 0, "off": 10}})).unwrap();
+        s.run("text.delete", &json!({})).unwrap();
+
+        // The default (only comments and formatting in balloons): struck through inline.
+        assert!(!s.revisions_in_balloons());
+        let (d, _) = draws(&mut s);
+        assert!(glyph_text(&d).contains("gone"), "{:?}", glyph_text(&d));
+
+        s.run("review.trackingOptions", &json!({"balloons": "revisions"})).unwrap();
+        assert!(s.revisions_in_balloons());
+        let (d, body_x) = draws(&mut s);
+        assert!(!glyph_text(&d).contains("gone"), "the deletion left the text: {:?}", glyph_text(&d));
+        let horizontal = lines(&d).into_iter().filter(|(_, y0, _, y1)| y0 == y1).count();
+        assert_eq!(horizontal, 0, "no strikethrough left behind: {:?}", lines(&d));
+        assert_eq!(lines(&d).into_iter().filter(|(x0, _, x1, _)| x0 == x1 && *x0 < body_x).count(), 1, "the changed line keeps its bar");
+        let at = wordcraft_doc::Pos::body(0, 5);
+        assert_eq!(deletion_balloons(&s), vec![DeletionBalloon { at: at.clone(), author: "Ana".into(), text: "gone ".into() }]);
+        // The balloon's anchor is where the deletion was: between "keep " and "stay".
+        let l = s.layout();
+        let (anchor, stay) = (l.caret(&at).unwrap().x, l.caret(&wordcraft_doc::Pos::body(0, 10)).unwrap().x);
+        assert!((anchor - stay).abs() < 0.01, "the deletion takes no room: {anchor} vs {stay}");
+
+        // No balloons beside the page while the Comments pane lists comments: inline again.
+        s.run("view.commentsPane", &json!({"value": true})).unwrap();
+        assert!(!s.revisions_in_balloons());
+        assert!(glyph_text(&draws(&mut s).0).contains("gone"));
+        s.run("view.commentsPane", &json!({"value": false})).unwrap();
+        assert!(!glyph_text(&draws(&mut s).0).contains("gone"));
+        s.run("review.trackingOptions", &json!({"balloons": "inline"})).unwrap();
+        assert!(!s.revisions_in_balloons());
+        assert!(glyph_text(&draws(&mut s).0).contains("gone"));
+    }
+
+    /// Deleted text running on across runs, separate deletions and a paragraph mark is one balloon
+    /// per author; a long deletion shows its start.
+    #[test]
+    fn deletion_balloons_join_runs_and_paragraph_marks_and_stay_short() {
+        use super::{DELETION_TEXT_CHARS, deletion_balloons};
+        let mut s = Session::new(Document::new());
+        s.author = "Ana".into();
+        s.run("document.setText", &json!({"text": "one two\nthree four"})).unwrap();
+        s.run("review.trackChanges", &json!({"value": true})).unwrap();
+        // "two", then the paragraph mark and "three" in a second deletion: one balloon.
+        s.run("select.range", &json!({"anchor": {"block": 0, "off": 4}, "focus": {"block": 0, "off": 7}})).unwrap();
+        s.run("text.delete", &json!({})).unwrap();
+        s.run("select.range", &json!({"anchor": {"block": 0, "off": 7}, "focus": {"block": 1, "off": 5}})).unwrap();
+        s.run("text.delete", &json!({})).unwrap();
+        // Bo's deletion right after Ana's is a balloon of its own.
+        s.author = "Bo".into();
+        s.run("select.range", &json!({"anchor": {"block": 1, "off": 5}, "focus": {"block": 1, "off": 10}})).unwrap();
+        s.run("text.delete", &json!({})).unwrap();
+        let b = deletion_balloons(&s);
+        let got: Vec<(&str, &str)> = b.iter().map(|d| (d.author.as_str(), d.text.as_str())).collect();
+        assert_eq!(got, vec![("Ana", "two¶three"), ("Bo", " four")]);
+        assert_eq!(b[0].at, wordcraft_doc::Pos::body(0, 4));
+
+        // A deletion far longer than a balloon shows: its first characters and an ellipsis.
+        let mut s = Session::new(Document::new());
+        let long = "word ".repeat(400);
+        s.run("document.setText", &json!({"text": long})).unwrap();
+        s.run("review.trackChanges", &json!({"value": true})).unwrap();
+        s.run("select.all", &json!({})).unwrap();
+        s.run("text.delete", &json!({})).unwrap();
+        let b = deletion_balloons(&s);
+        assert_eq!(b.len(), 1);
+        assert_eq!(b[0].text.chars().count(), DELETION_TEXT_CHARS + 1);
+        assert!(b[0].text.starts_with("word word") && b[0].text.ends_with('…'));
+    }
+
+    /// #404: the source of a move is a deletion revision with a move name. With revisions in
+    /// balloons it leaves the text like a deletion but has only its "Moved from" balloon, not a
+    /// "Deleted: …" one as well; a plain deletion right after it is a balloon of its own.
+    #[test]
+    fn a_moves_source_gets_no_deletion_balloon() {
+        use super::{DeletionBalloon, deletion_balloons, has_deletions, move_changes};
+        use wordcraft_doc::Pos;
+        let mut s = Session::new(Document::new());
+        s.run("document.setText", &json!({"text": "First one.\nSecond one.\nThird one."})).unwrap();
+        s.run("file.setAuthor", &json!({"name": "Ana"})).unwrap();
+        s.run("review.trackChanges", &json!({"value": true})).unwrap();
+        // The second paragraph, with its mark, cut and pasted before the first: a move.
+        s.run("select.range", &json!({"anchor": {"block": 1, "off": 0}, "focus": {"block": 2, "off": 0}})).unwrap();
+        s.run("edit.cut", &json!({})).unwrap();
+        s.run("caret.set", &json!({"pos": {"block": 0, "off": 0}})).unwrap();
+        s.run("edit.paste", &json!({})).unwrap();
+        s.run("review.trackingOptions", &json!({"balloons": "revisions"})).unwrap();
+        assert!(s.revisions_in_balloons());
+
+        let ends: Vec<(Pos, bool)> = move_changes(&s).into_iter().map(|(at, _, from)| (at, from)).collect();
+        assert_eq!(ends, vec![(Pos::body(0, 0), false), (Pos::body(2, 0), true)]);
+        assert!(deletion_balloons(&s).is_empty(), "the move's source has its \"Moved from\" balloon only: {:?}", deletion_balloons(&s));
+        assert!(!has_deletions(&s.doc), "a move alone needs no deletion balloons");
+        assert_eq!(glyph_text(&draws(&mut s).0), "Second one.First one.Third one.", "the moved-away text left the text");
+
+        // "Third " deleted right where the moved-away paragraph ends: not joined to it.
+        s.run("select.range", &json!({"anchor": {"block": 3, "off": 0}, "focus": {"block": 3, "off": 6}})).unwrap();
+        s.run("text.delete", &json!({})).unwrap();
+        assert!(has_deletions(&s.doc));
+        assert_eq!(deletion_balloons(&s), vec![DeletionBalloon { at: Pos::body(3, 0), author: "Ana".into(), text: "Third ".into() }]);
+        assert_eq!(move_changes(&s).len(), 2, "the move keeps both its balloons");
+    }
+
+    /// Revisions in balloons take deletions out of the body only, where their balloons are:
+    /// headers, footers, footnotes, endnotes and text boxes get no balloons, so their deletions
+    /// stay in the text, struck through, as in the other modes.
+    #[test]
+    fn deletions_outside_the_body_stay_inline_when_revisions_go_in_balloons() {
+        use super::{DeletionBalloon, deletion_balloons};
+        use wordcraft_doc::{Path, Pos, StoryRef};
+        let mut s = Session::new(Document::new());
+        s.view.proofing = false;
+        s.author = "Ana".into();
+        s.run("document.setText", &json!({"text": "Body zeta keep"})).unwrap();
+        let part = |v: serde_json::Value, key: &str| StoryRef::Part(v[key].as_u64().unwrap() as u32);
+        let header = part(s.run("insert.header", &json!({"text": "Head alpha"})).unwrap(), "story");
+        s.run("insert.closeHeader", &json!({})).unwrap();
+        let footer = part(s.run("insert.footer", &json!({"text": "Foot beta"})).unwrap(), "story");
+        s.run("insert.closeHeader", &json!({})).unwrap();
+        let in_body = json!({"pos": {"block": 0, "off": 4}});
+        s.run("caret.set", &in_body).unwrap();
+        let footnote = part(s.run("references.footnote", &json!({"text": "Note gamma"})).unwrap(), "id");
+        s.run("caret.set", &in_body).unwrap();
+        let endnote = part(s.run("references.endnote", &json!({"text": "End delta"})).unwrap(), "id");
+        s.run("caret.set", &in_body).unwrap();
+        let text_box = part(s.run("insert.textBox", &json!({"text": "Box epsilon"})).unwrap(), "story");
+
+        // With Track Changes on, a word deleted in each story.
+        s.run("review.trackChanges", &json!({"value": true})).unwrap();
+        let words = [(StoryRef::Body, "zeta"), (header, "alpha"), (footer, "beta"), (footnote, "gamma"), (endnote, "delta"), (text_box, "epsilon")];
+        for (story, word) in words {
+            let at = s.doc.para(story, &Path::top(0)).and_then(|p| p.text.find(word)).unwrap();
+            let pos = |off: usize| json!({"story": story, "path": [0], "off": off});
+            s.run("select.range", &json!({"anchor": pos(at), "focus": pos(at + word.len())})).unwrap();
+            s.run("text.delete", &json!({})).unwrap();
+            let p = s.doc.para(story, &Path::top(0)).unwrap();
+            assert!(p.run_ranges().any(|(r, c)| c.del.is_some() && p.text.get(r) == Some(word)), "{word} is a tracked deletion");
+        }
+        let struck = |d: &[Draw]| lines(d).into_iter().filter(|(_, y0, _, y1)| y0 == y1).count();
+
+        // Comments and formatting in balloons: every deletion struck through where it was.
+        let (d, _) = draws(&mut s);
+        let text = glyph_text(&d);
+        for (_, word) in words {
+            assert!(text.contains(word), "{word} in {text:?}");
+        }
+        let all_struck = struck(&d);
+
+        // Revisions in balloons: only the body's deletion leaves the text, for its balloon.
+        s.run("review.trackingOptions", &json!({"balloons": "revisions"})).unwrap();
+        assert!(s.revisions_in_balloons());
+        let (d, _) = draws(&mut s);
+        let text = glyph_text(&d);
+        assert!(!text.contains("zeta"), "the body's deletion left the text: {text:?}");
+        for (_, word) in &words[1..] {
+            assert!(text.contains(word), "{word} stays inline: {text:?}");
+        }
+        assert_eq!(struck(&d), all_struck - 1, "the other deletions stay struck through");
+        // Its balloon is the only one: the notes' and text box's objects sit before "zeta".
+        let at = s.doc.para(StoryRef::Body, &Path::top(0)).and_then(|p| p.text.find("zeta")).unwrap();
+        assert_eq!(deletion_balloons(&s), vec![DeletionBalloon { at: Pos::body(0, at), author: "Ana".into(), text: "zeta".into() }]);
+    }
+
     fn body_para(s: &Session) -> &wordcraft_doc::Paragraph {
         s.doc.para(wordcraft_doc::StoryRef::Body, &wordcraft_doc::Path::top(0)).unwrap()
     }
diff --git a/crates/engine/src/cmd/smart_art.rs b/crates/engine/src/cmd/smart_art.rs
new file mode 100644
index 0000000000..5ebaea922e
--- /dev/null
+++ b/crates/engine/src/cmd/smart_art.rs
@@ -0,0 +1,286 @@
+//! Insert › SmartArt and the SmartArt Design tab: insert a SmartArt graphic, edit its items (the
+//! Text Pane, Add Shape, Promote, Demote), change its layout and colours, reset it.
+//!
+//! A SmartArt graphic is an inline [`InlineObject::Graphic`] whose graphic keeps its model
+//! ([`SmartArtSpec`]); WordCraft lays it out and draws it (see `wordcraft_docx::smart_art_items`)
+//! and saves it as diagram parts. SmartArt made by other programs is shown as it is; these
+//! commands only edit graphics with a model. Each command is one undo step.
+
+use std::sync::Arc;
+
+use serde_json::{Value, json};
+use wordcraft_doc::graphic::{Graphic, GraphicKind};
+use wordcraft_doc::para::{Float, InlineObject};
+use wordcraft_doc::props::Rgb;
+use wordcraft_doc::smart_art::{MAX_ITEMS, MAX_LEVEL, SmartArtColors, SmartArtItem, SmartArtLayout, SmartArtSpec, clean_text};
+
+use super::delete_selection;
+use super::objects::selected;
+use crate::{CmdError, CmdResult, CommandSpec, Selection, Session, p};
+
+/// A new graphic's size: 6 × 3.5 inches, points (narrower when the text column is).
+pub const DEFAULT_W: f32 = 432.0;
+pub const DEFAULT_H: f32 = 252.0;
+
+const LAYOUTS: &str = "basicList|process|cycle|hierarchy|pyramid|radial|matrix|venn";
+const COLORS: &str = "accent1|accent2|accent3|accent4|accent5|accent6|colorful";
+const ITEMS: &str = r#"[string | {"text": string, "level"?: 0-7}] (a string's leading tabs are its level)"#;
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec::new("insert.smartArt", "SmartArt", "Insert › Illustrations", insert).params(
+            r#"{"layout"?: "basicList|process|cycle|hierarchy|pyramid|radial|matrix|venn", "items"?: [string | {"text": string, "level"?: 0-7}], "colors"?: "accent1…accent6|colorful", "width"?: pt, "height"?: pt} (no items: sample items for the layout)"#,
+        ),
+        CommandSpec::new("smartArt.items", "Edit Items", "SmartArt Design › Create Graphic", |s, v| {
+            let items = items_of(v.get("items").ok_or_else(|| CmdError::Params(format!("`items` is required: {ITEMS}")))?)?;
+            edit(s, move |g| {
+                g.items = items.clone();
+                Ok(())
+            })
+        })
+        .params(r#"{"items": [string | {"text": string, "level"?: 0-7}]} (replaces the outline)"#)
+        .when(has_smart_art),
+        CommandSpec::new("smartArt.textPane", "Text Pane", "SmartArt Design › Create Graphic", |s, v| {
+            let on = p::bool(v, "value").unwrap_or(!s.view.smart_art_pane);
+            s.view.smart_art_pane = on;
+            Ok(json!({"value": on}))
+        })
+        .params(r#"{"value"?: bool} (no value: show or hide the Text Pane)"#)
+        .pure(),
+        CommandSpec::new("smartArt.addShape", "Add Shape", "SmartArt Design › Create Graphic", |s, v| {
+            let after = index(v, "after")?;
+            let text = p::str(v, "text").map(clean_text).unwrap_or_default();
+            let below = p::bool(v, "below").unwrap_or(false);
+            edit(s, move |g| {
+                if g.items.len() >= MAX_ITEMS {
+                    return Err(CmdError::Failed(format!("a SmartArt graphic holds at most {MAX_ITEMS} items")));
+                }
+                let Some(last) = g.items.len().checked_sub(1) else {
+                    g.items.push(SmartArtItem::new(text.clone(), 0));
+                    return Ok(());
+                };
+                let at = after.unwrap_or(last).min(last);
+                let level = g.items.get(at).map_or(0, |it| it.level);
+                if below {
+                    // Under the item: its first sub-item.
+                    g.items.insert(at + 1, SmartArtItem::new(text.clone(), level.saturating_add(1).min(MAX_LEVEL)));
+                } else {
+                    // After the item and everything under it, at its level.
+                    let end = g.descendants(at).end;
+                    g.items.insert(end, SmartArtItem::new(text.clone(), level));
+                }
+                Ok(())
+            })
+        })
+        .params(r#"{"after"?: item index (default: the last), "text"?: string, "below"?: bool (a sub-item instead of the next item)}"#)
+        .when(has_smart_art),
+        CommandSpec::new("smartArt.promote", "Promote", "SmartArt Design › Create Graphic", |s, v| {
+            let i = index(v, "index")?;
+            edit(s, move |g| {
+                let i = item_at(g, i)?;
+                if g.items.get(i).is_none_or(|it| it.level == 0) {
+                    return Err(CmdError::Failed("this item is already at the top level".into()));
+                }
+                for j in std::iter::once(i).chain(g.descendants(i)) {
+                    if let Some(it) = g.items.get_mut(j) {
+                        it.level = it.level.saturating_sub(1);
+                    }
+                }
+                Ok(())
+            })
+        })
+        .params(r#"{"index"?: item index (default: the last)} (the item and the items under it move up a level)"#)
+        .when(has_smart_art),
+        CommandSpec::new("smartArt.demote", "Demote", "SmartArt Design › Create Graphic", |s, v| {
+            let i = index(v, "index")?;
+            edit(s, move |g| {
+                let i = item_at(g, i)?;
+                let prev = i.checked_sub(1).and_then(|p| g.items.get(p)).map(|it| it.level);
+                let level = g.items.get(i).map_or(0, |it| it.level);
+                let deepest = std::iter::once(i).chain(g.descendants(i)).filter_map(|j| g.items.get(j)).map(|it| it.level).max().unwrap_or(0);
+                if prev.is_none_or(|p| p < level) || deepest >= MAX_LEVEL {
+                    return Err(CmdError::Failed("this item can't go down a level (it needs an item before it at its level)".into()));
+                }
+                for j in std::iter::once(i).chain(g.descendants(i)) {
+                    if let Some(it) = g.items.get_mut(j) {
+                        it.level = it.level.saturating_add(1);
+                    }
+                }
+                Ok(())
+            })
+        })
+        .params(r#"{"index"?: item index (default: the last)} (the item and the items under it move down a level)"#)
+        .when(has_smart_art),
+        CommandSpec::new("smartArt.layout", "Change Layout", "SmartArt Design › Layouts", |s, v| {
+            let layout = layout_of(v)?.ok_or_else(|| CmdError::Params(format!("`layout` is required: {LAYOUTS}")))?;
+            edit(s, move |g| {
+                g.layout = layout;
+                Ok(())
+            })
+        })
+        .params(r#"{"layout": "basicList|process|cycle|hierarchy|pyramid|radial|matrix|venn"}"#)
+        .when(has_smart_art),
+        CommandSpec::new("smartArt.colors", "Change Colors", "SmartArt Design › SmartArt Styles", |s, v| {
+            let colors = colors_of(v)?.ok_or_else(|| CmdError::Params(format!("`variant` is required: {COLORS}")))?;
+            edit(s, move |g| {
+                g.colors = colors;
+                Ok(())
+            })
+        })
+        .params(r#"{"variant": "accent1|accent2|accent3|accent4|accent5|accent6|colorful"}"#)
+        .when(has_smart_art),
+        CommandSpec::new("smartArt.reset", "Reset Graphic", "SmartArt Design › Reset", |s, _| {
+            edit(s, |g| {
+                g.colors = SmartArtColors::default();
+                Ok(())
+            })
+        })
+        .params("{} (back to the default colours; the items and layout stay)")
+        .when(has_smart_art),
+    ]
+}
+
+/// The selected SmartArt graphic's model, when it has one.
+pub fn selected_smart_art(s: &Session) -> Option<Arc<SmartArtSpec>> {
+    match selected(s) {
+        Some((_, InlineObject::Graphic { graphic, .. })) => graphic.smart_art.clone(),
+        _ => None,
+    }
+}
+
+fn has_smart_art(s: &Session) -> Option<&'static str> {
+    match selected(s) {
+        Some((_, InlineObject::Graphic { graphic, .. })) if graphic.smart_art.is_some() => None,
+        Some((_, InlineObject::Graphic { graphic, .. })) if graphic.kind == GraphicKind::Diagram => {
+            Some("this SmartArt was made in another program: WordCraft shows it but can't edit it")
+        }
+        _ => Some("select a SmartArt graphic first"),
+    }
+}
+
+/// The graphic for `spec` laid out `w` × `h` points in the theme's colours.
+pub fn smart_art_graphic(spec: SmartArtSpec, theme: &[Rgb], w: f32, h: f32) -> Graphic {
+    let spec = spec.sanitized();
+    let items = wordcraft_docx::smart_art_items(&spec, theme, w, h);
+    Graphic { kind: GraphicKind::Diagram, items, w, h, source: None, chart: None, smart_art: Some(Arc::new(spec)) }
+}
+
+/// Lay the SmartArt graphic of `o` out again at its current size (after a resize), if it has a model.
+pub fn redraw(o: &mut InlineObject, theme: &[Rgb]) {
+    if let InlineObject::Graphic { w, h, graphic, .. } = o
+        && let Some(spec) = graphic.smart_art.as_deref()
+    {
+        *graphic = Arc::new(smart_art_graphic(spec.clone(), theme, *w, *h));
+    }
+}
+
+/// `layout` of the params, if given.
+fn layout_of(v: &Value) -> Result<Option<SmartArtLayout>, CmdError> {
+    match v.get("layout") {
+        None | Some(Value::Null) => Ok(None),
+        Some(Value::String(id)) => {
+            SmartArtLayout::from_id(id).map(Some).ok_or_else(|| CmdError::Params(format!("unknown layout `{}`: {LAYOUTS}", clean_text(id))))
+        }
+        Some(_) => Err(CmdError::Params(format!("`layout`: {LAYOUTS}"))),
+    }
+}
+
+/// `variant` (or `colors`) of the params, if given.
+fn colors_of(v: &Value) -> Result<Option<SmartArtColors>, CmdError> {
+    match v.get("variant").or_else(|| v.get("colors")) {
+        None | Some(Value::Null) => Ok(None),
+        Some(Value::String(id)) => {
+            SmartArtColors::from_id(id).map(Some).ok_or_else(|| CmdError::Params(format!("unknown colours `{}`: {COLORS}", clean_text(id))))
+        }
+        Some(_) => Err(CmdError::Params(format!("`variant`: {COLORS}"))),
+    }
+}
+
+/// An item index param, if given.
+fn index(v: &Value, k: &str) -> Result<Option<usize>, CmdError> {
+    match v.get(k) {
+        None | Some(Value::Null) => Ok(None),
+        Some(_) => p::u64(v, k)
+            .map(|i| Some(usize::try_from(i).unwrap_or(usize::MAX)))
+            .ok_or_else(|| CmdError::Params(format!("`{k}`: an item index (0 is the first)"))),
+    }
+}
+
+/// Item `i` of `g` (default: the last).
+fn item_at(g: &SmartArtSpec, i: Option<usize>) -> Result<usize, CmdError> {
+    let last = g.items.len().checked_sub(1).ok_or_else(|| CmdError::Failed("the graphic has no items".into()))?;
+    match i {
+        None => Ok(last),
+        Some(i) if i <= last => Ok(i),
+        Some(i) => Err(CmdError::Params(format!("no item {i}: the graphic has {} items", last + 1))),
+    }
+}
+
+/// Items from JSON (at most [`MAX_ITEMS`]): strings (leading tabs give the level) or
+/// `{"text", "level"}` objects.
+fn items_of(v: &Value) -> Result<Vec<SmartArtItem>, CmdError> {
+    let a = v.as_array().ok_or_else(|| CmdError::Params(format!("`items`: {ITEMS}")))?;
+    let items = a
+        .iter()
+        .take(MAX_ITEMS)
+        .map(|it| match it {
+            Value::String(t) => {
+                let tabs = t.chars().take_while(|c| *c == '\t').count();
+                Ok(SmartArtItem::new(clean_text(t), u8::try_from(tabs).unwrap_or(MAX_LEVEL).min(MAX_LEVEL)))
+            }
+            Value::Object(_) => {
+                let text = match it.get("text") {
+                    Some(Value::String(t)) => clean_text(t),
+                    None | Some(Value::Null) => String::new(),
+                    Some(other) => clean_text(&other.to_string()),
+                };
+                let level = p::u64(it, "level").unwrap_or(0).min(u64::from(MAX_LEVEL));
+                Ok(SmartArtItem::new(text, u8::try_from(level).unwrap_or(MAX_LEVEL)))
+            }
+            _ => Err(CmdError::Params(format!("`items`: {ITEMS}"))),
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+    if items.is_empty() {
+        return Err(CmdError::Params("`items` needs at least one item".into()));
+    }
+    Ok(items)
+}
+
+fn insert(s: &mut Session, v: &Value) -> CmdResult {
+    let layout = layout_of(v)?.unwrap_or_default();
+    let mut spec = SmartArtSpec::sample(layout);
+    if let Some(items) = v.get("items").filter(|i| !i.is_null()) {
+        spec.items = items_of(items)?;
+    }
+    if let Some(c) = colors_of(v)? {
+        spec.colors = c;
+    }
+    // Fitted to the text width, as a new graphic is.
+    let max_w = s.doc.sections().first().map(|(_, sp)| sp.text_width()).unwrap_or(468.0).max(36.0);
+    let w = p::f32(v, "width").unwrap_or(DEFAULT_W).clamp(36.0, 2000.0).min(max_w);
+    let h = p::f32(v, "height").unwrap_or(DEFAULT_H).clamp(36.0, 2000.0);
+    let graphic = smart_art_graphic(spec, &s.doc.settings.theme_colors, w, h);
+    let out = json!({"smartArt": graphic.smart_art.as_deref(), "width": w, "height": h});
+    let props = s.typing_props();
+    let at = delete_selection(s)?;
+    let obj = InlineObject::Graphic { w, h, alt: String::new(), float: Float::default(), graphic: Arc::new(graphic) };
+    let end = s.doc.insert_object(&at, obj, &props)?;
+    s.sel = Selection { anchor: at, focus: end };
+    Ok(out)
+}
+
+/// Change the selected graphic's model with `f`, then lay it out again at its size.
+fn edit(s: &mut Session, f: impl Fn(&mut SmartArtSpec) -> Result<(), CmdError>) -> CmdResult {
+    let (pos, obj) = selected(s).ok_or_else(|| CmdError::Disabled("select a SmartArt graphic first".into()))?;
+    let InlineObject::Graphic { w, h, graphic, .. } = obj else { return Err(CmdError::Disabled("select a SmartArt graphic first".into())) };
+    let mut spec = graphic.smart_art.as_deref().cloned().ok_or_else(|| CmdError::Disabled("this SmartArt graphic can't be edited".into()))?;
+    f(&mut spec)?;
+    let next = Arc::new(smart_art_graphic(spec, &s.doc.settings.theme_colors, w, h));
+    let out = json!({"smartArt": next.smart_art.as_deref()});
+    let para = s.doc.para_mut(pos.story, &pos.path)?;
+    if let Some(InlineObject::Graphic { graphic, .. }) = para.object_at_mut(pos.off) {
+        *graphic = next;
+    }
+    para.touch();
+    Ok(out)
+}
diff --git a/crates/engine/src/cmd/table.rs b/crates/engine/src/cmd/table.rs
index 8eace0a4aa..fed691fcb3 100644
--- a/crates/engine/src/cmd/table.rs
+++ b/crates/engine/src/cmd/table.rs
@@ -144,6 +144,23 @@ pub fn specs() -> Vec<CommandSpec> {
                 }
             })
         })),
+        // Table Properties › Alt Text: the title (`w:tblCaption`) and description (`w:tblDescription`).
+        t(CommandSpec::new("table.altText", "Alt Text", "Table Layout › Table › Properties", |s, v| {
+            let (title, text) = (p::str(v, "title"), p::str(v, "text"));
+            if title.is_none() && text.is_none() {
+                return Err(CmdError::Params("`text` or `title` (string) is required".into()));
+            }
+            let set = |x: Option<&str>, cur: &Option<String>| match x {
+                Some(x) if x.trim().is_empty() => None,
+                Some(x) => Some(wordcraft_doc::para::cap_alt(x)),
+                None => cur.clone(),
+            };
+            with_table(s, |t| {
+                t.props.caption = set(title, &t.props.caption);
+                t.props.description = set(text, &t.props.description);
+            })
+        })
+        .params(r#"{"text"?: string, "title"?: string} (empty clears)"#)),
         t(CommandSpec::new("table.sort", "Sort", "Table Layout › Data", sort_table)
             .params(r#"{"column"?: n, "descending"?: bool, "header"?: bool}"#)),
         t(CommandSpec::new("table.toText", "Convert to Text", "Table Layout › Data", to_text).params(r#"{"separator"?: "tab|comma|paragraph"}"#)),
@@ -398,7 +415,7 @@ fn with_cells(s: &mut Session, f: impl Fn(&mut wordcraft_doc::Cell)) -> CmdResul
 
 /// Table Layout › Text Direction: turn the selected cells' text. Without a value it cycles the
 /// caret cell's direction (horizontal → down → up) and gives every selected cell the result.
-fn text_direction(s: &mut Session, v: &Value) -> CmdResult {
+pub(crate) fn text_direction(s: &mut Session, v: &Value) -> CmdResult {
     let (tp, r, c) = cell(s)?;
     let dir = match p::str(v, "value") {
         Some("horizontal" | "lrTb") => TextDirection::Horizontal,
@@ -480,13 +497,28 @@ fn del_row(s: &mut Session, _: &Value) -> CmdResult {
 
 fn del_col(s: &mut Session, _: &Value) -> CmdResult {
     let (tp, r, c) = cell(s)?;
+    let cells = selected_cells(s);
     let story = s.sel.focus.story;
     let t = s.doc.table_mut(story, &tp)?;
     if t.grid.len() <= 1 {
         return del_table(s, &Value::Null);
     }
-    let g = t.grid_col(r, c);
-    t.delete_col(g);
+    // Every grid column a selected cell covers goes (the caret's alone without a selection).
+    let mut cols = std::collections::BTreeSet::new();
+    for (rr, cc) in cells {
+        let g = t.grid_col(rr, cc);
+        let span = t.rows.get(rr).and_then(|x| x.cells.get(cc)).map_or(1, wordcraft_doc::Cell::span);
+        cols.extend(g..g.saturating_add(span).min(t.grid.len()));
+    }
+    if cols.is_empty() {
+        cols.insert(t.grid_col(r, c));
+    }
+    if cols.len() >= t.grid.len() {
+        return del_table(s, &Value::Null);
+    }
+    for g in cols.iter().rev() {
+        t.delete_col(*g);
+    }
     // Rows left without cells are dropped; if that was every row, no table is left.
     if t.rows.is_empty() {
         return del_table(s, &Value::Null);
@@ -527,7 +559,10 @@ fn split_table(s: &mut Session, _: &Value) -> CmdResult {
     let story = s.sel.focus.story;
     let t = s.doc.table_mut(story, &tp)?;
     let tail_rows = t.rows.split_off(r);
-    let tail = Table { props: t.props.clone(), grid: t.grid.clone(), rows: tail_rows };
+    // Content controls closing after the table now close after its second part.
+    let close = std::mem::take(&mut t.controls.close);
+    let controls = wordcraft_doc::ControlWrap { open: Vec::new(), close };
+    let tail = Table { props: t.props.clone(), grid: t.grid.clone(), rows: tail_rows, controls };
     let after = tp.with_last(tp.last() + 1);
     s.doc.insert_block(story, &after, Block::Para(Paragraph::new()))?;
     s.doc.insert_block(story, &after.with_last(after.last() + 1), Block::Table(tail))?;
diff --git a/crates/engine/src/cmd/table_draw.rs b/crates/engine/src/cmd/table_draw.rs
index 3df1977d89..53b202b043 100644
--- a/crates/engine/src/cmd/table_draw.rs
+++ b/crates/engine/src/cmd/table_draw.rs
@@ -60,7 +60,7 @@ fn cell_boxes(l: &DocLayout, page: usize) -> Vec<CellBox> {
     pg.items
         .iter()
         .filter_map(|it| match it {
-            Placed::Cell { rect, table, row, cell, story } => {
+            Placed::Cell { rect, table, row, cell, story, .. } => {
                 Some(CellBox { rect: *rect, table: table.clone(), story: *story, row: *row, cell: *cell })
             }
             _ => None,
@@ -316,7 +316,7 @@ fn split_rows(s: &mut Session, l: &DocLayout, page: usize, y: f32, (xa, xb): (f3
     }
     let t = s.doc.table_mut(story, &tp)?;
     let Some(row) = t.rows.get_mut(r) else { return Err(CmdError::Failed("the row isn't there any more".into())) };
-    let mut new_row = wordcraft_doc::Row { props: row.props.clone(), cells: Vec::with_capacity(row.cells.len()) };
+    let mut new_row = wordcraft_doc::Row { props: row.props.clone(), cells: Vec::with_capacity(row.cells.len()), controls: Default::default() };
     new_row.props.header = false;
     if top.is_finite() && bottom.is_finite() && bottom > top {
         let rule = if row.props.height_rule == HeightRule::Exact { HeightRule::Exact } else { HeightRule::AtLeast };
@@ -527,6 +527,29 @@ mod tests {
         assert!(s.run("table.draw", &json!({})).is_err());
     }
 
+    /// Erasing a horizontal border merges the cells into one laid-out cell (#640): the lower
+    /// row's box is `covered`, the merged cell's box spans both rows, and erasing the border
+    /// below the merge extends it.
+    #[test]
+    fn erasing_a_horizontal_border_lays_the_merge_out_as_one_cell() {
+        let mut s = Session::new(wordcraft_doc::Document::new());
+        s.run("insert.table", &json!({"rows": 3, "cols": 2})).unwrap();
+        let (a, b) = (cell_rect(&mut s, 0, 0), cell_rect(&mut s, 1, 0));
+        s.run("table.eraser", &json!({"page": 0, "x": a.x + a.w / 2.0, "y": a.bottom() + 0.5})).unwrap();
+        let t = first_table(&s);
+        assert_eq!((t.rows[0].cells[0].props.vmerge, t.rows[1].cells[0].props.vmerge), (VMerge::Restart, VMerge::Continue));
+        let merged = cell_rect(&mut s, 0, 0);
+        assert!((merged.bottom() - b.bottom()).abs() < 0.5 && merged.h > a.h * 1.9, "{merged:?}");
+        let covered = s.layout().pages[0].items.iter().any(|it| matches!(it, Placed::Cell { row: 1, cell: 0, covered: true, .. }));
+        assert!(covered, "the continuation row's box is covered");
+        let hit = s.layout().cell_at(0, merged.x + 3.0, b.y + b.h / 2.0).map(|c| (c.2, c.3));
+        assert_eq!(hit, Some((0, 0)), "a click in the lower half is in the merged cell");
+        // The border below the merge: the merge grows to three rows.
+        s.run("table.eraser", &json!({"page": 0, "x": merged.x + merged.w / 2.0, "y": merged.bottom() + 0.5})).unwrap();
+        let t = first_table(&s);
+        assert_eq!(t.rows[2].cells[0].props.vmerge, VMerge::Continue);
+    }
+
     /// A vertical line through a cell splits it into two columns; a horizontal one splits a row;
     /// the eraser merges the cells back; each is one undo step.
     #[test]
diff --git a/crates/engine/src/cmd/table_resize.rs b/crates/engine/src/cmd/table_resize.rs
new file mode 100644
index 0000000000..f7aab43e8b
--- /dev/null
+++ b/crates/engine/src/cmd/table_resize.rs
@@ -0,0 +1,542 @@
+//! Resizing a table with the mouse, like Word: drag a border between columns (or the table's
+//! right edge), a row's bottom border, or the small handle just outside the table's bottom-right
+//! corner to scale the whole table. The geometry comes from the layout (what is on the page, in
+//! page points), so the result is what the drag showed even when autofit or a percentage width
+//! made the drawn columns differ from the stored grid. The app sends each finished drag here,
+//! so every drag is one undo step.
+
+use serde_json::Value;
+use wordcraft_doc::props::HeightRule;
+use wordcraft_doc::{Document, Path, StoryRef, Table};
+use wordcraft_geom::Rect;
+use wordcraft_layout::{DocLayout, Placed};
+
+use super::sel_result;
+use crate::{CmdError, CmdResult, CommandSpec, Session, p};
+
+/// How near (points) a border has to be to the pointer, by default.
+pub const REACH: f32 = 3.0;
+/// The corner handle's side (points); it sits just outside the table's bottom-right corner.
+pub const HANDLE: f32 = 6.0;
+/// The narrowest column a drag leaves (points).
+pub const MIN_COL: f32 = 6.0;
+/// The lowest row a drag leaves (points).
+pub const MIN_ROW: f32 = 4.0;
+/// The largest column width or row height a drag sets (points; Word's 22 inches).
+const MAX_LEN: f32 = 1584.0;
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![CommandSpec::new("table.resizeDrag", "Resize Table by Dragging", "Table Layout › Cell Size", resize_drag).params(
+        r#"{"page": n, "x": pt, "y": pt, "toX": pt, "toY": pt, "shift"?: bool, "reach"?: pt} (a mouse drag in page points, 0-based page, starting on a table border or the resize handle: a column border moves (the column to its right gives or takes the difference, so the table keeps its width; with shift, or on the table's right edge, only the column left of it changes); a row's bottom border sets that row's height; the handle just outside the bottom-right corner scales every column and the rows on that page. `reach` (default 3) is how near the start has to be.)"#,
+    )]
+}
+
+/// What a press on the page would grab.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Edge {
+    /// The vertical border at grid line `line` (1 = between the first two columns; the last is
+    /// the table's right edge).
+    Column(usize),
+    /// The bottom border of row `row`.
+    Row(usize),
+    /// The resize handle at the bottom-right corner.
+    Corner,
+}
+
+/// A row of the table as drawn on one page.
+#[derive(Clone, Debug, PartialEq)]
+pub struct DrawnRow {
+    pub row: usize,
+    pub top: f32,
+    pub bottom: f32,
+    /// Grid lines that are cell borders in this row (a merged cell hides the ones it covers).
+    edges: Vec<usize>,
+}
+
+/// A table border (or the handle) under the pointer, with the table's drawn geometry.
+#[derive(Clone, Debug, PartialEq)]
+pub struct ResizeTarget {
+    pub edge: Edge,
+    pub story: StoryRef,
+    pub table: Path,
+    /// Drawn grid lines, page x, left to right (columns + 1 of them).
+    pub cols: Vec<f32>,
+    /// Drawn rows on this page, top to bottom.
+    pub rows: Vec<DrawnRow>,
+    /// Whether the table's last row is on this page (the handle is shown only then).
+    pub ends_here: bool,
+}
+
+/// What a drag to a point would make of the table.
+#[derive(Clone, Debug, Default, PartialEq)]
+pub struct Plan {
+    /// New column widths (points), when the columns change.
+    pub widths: Option<Vec<f32>>,
+    /// New heights (points) of these rows.
+    pub heights: Vec<(usize, f32)>,
+}
+
+impl ResizeTarget {
+    pub fn left(&self) -> f32 {
+        self.cols.first().copied().unwrap_or(0.0)
+    }
+    pub fn right(&self) -> f32 {
+        self.cols.last().copied().unwrap_or(0.0)
+    }
+    pub fn top(&self) -> f32 {
+        self.rows.first().map_or(0.0, |r| r.top)
+    }
+    pub fn bottom(&self) -> f32 {
+        self.rows.last().map_or(0.0, |r| r.bottom)
+    }
+    /// The drawn column widths.
+    pub fn widths(&self) -> Vec<f32> {
+        self.cols.windows(2).map(|w| (w[1] - w[0]).max(0.0)).collect()
+    }
+    /// The resize handle's square (page points).
+    pub fn handle(&self) -> Rect {
+        Rect::new(self.right() + 1.0, self.bottom() + 1.0, HANDLE, HANDLE)
+    }
+
+    /// The new widths and heights a drag that moved the pointer by (`dx`, `dy`) points gives.
+    pub fn plan(&self, dx: f32, dy: f32, shift: bool) -> Plan {
+        let (dx, dy) =
+            (if dx.is_finite() { dx.clamp(-MAX_LEN, MAX_LEN) } else { 0.0 }, if dy.is_finite() { dy.clamp(-MAX_LEN, MAX_LEN) } else { 0.0 });
+        let mut w = self.widths();
+        match self.edge {
+            Edge::Column(line) => {
+                let Some(left) = line.checked_sub(1).and_then(|i| w.get(i).copied()) else { return Plan::default() };
+                let right = w.get(line).copied();
+                let (new_left, new_right) = match right {
+                    // An inner border: the neighbour on the right makes up the difference.
+                    Some(right) if !shift => {
+                        let d = dx.clamp(MIN_COL - left, (right - MIN_COL).max(MIN_COL - left));
+                        (left + d, Some(right - d))
+                    }
+                    // The right edge (or Shift): only the column on the left changes.
+                    _ => ((left + dx).clamp(MIN_COL, MAX_LEN), None),
+                };
+                if let Some(x) = w.get_mut(line - 1) {
+                    *x = new_left;
+                }
+                if let (Some(r), Some(x)) = (new_right, w.get_mut(line)) {
+                    *x = r;
+                }
+                Plan { widths: Some(w), heights: Vec::new() }
+            }
+            Edge::Row(row) => {
+                let Some(r) = self.rows.iter().find(|r| r.row == row) else { return Plan::default() };
+                Plan { widths: None, heights: vec![(row, (r.bottom - r.top + dy).clamp(MIN_ROW, MAX_LEN))] }
+            }
+            Edge::Corner => {
+                let (width, height) = (self.right() - self.left(), self.bottom() - self.top());
+                let kx = if width > 1.0 { ((width + dx) / width).clamp(0.01, 100.0) } else { 1.0 };
+                let ky = if height > 1.0 { ((height + dy) / height).clamp(0.01, 100.0) } else { 1.0 };
+                let widths = ((kx - 1.0).abs() > 0.001).then(|| w.iter().map(|x| (x * kx).clamp(MIN_COL, MAX_LEN)).collect());
+                let heights = if (ky - 1.0).abs() > 0.001 {
+                    self.rows.iter().map(|r| (r.row, ((r.bottom - r.top) * ky).clamp(MIN_ROW, MAX_LEN))).collect()
+                } else {
+                    Vec::new()
+                };
+                Plan { widths, heights }
+            }
+        }
+    }
+}
+
+/// A table cell's area on a page.
+struct CellBox {
+    rect: Rect,
+    table: Path,
+    story: StoryRef,
+    row: usize,
+    cell: usize,
+}
+
+fn cell_boxes(l: &DocLayout, page: usize) -> Vec<CellBox> {
+    let Some(pg) = l.pages.get(page) else { return Vec::new() };
+    pg.items
+        .iter()
+        .filter_map(|it| match it {
+            Placed::Cell { rect, table, row, cell, story, .. } => {
+                Some(CellBox { rect: *rect, table: table.clone(), story: *story, row: *row, cell: *cell })
+            }
+            _ => None,
+        })
+        .collect()
+}
+
+/// The drawn geometry of one table on a page, from its cells' boxes.
+fn geometry(t: &Table, boxes: &[&CellBox]) -> Option<(Vec<f32>, Vec<DrawnRow>)> {
+    let n = t.cols();
+    if n == 0 || n > wordcraft_doc::table::MAX_COLS || boxes.is_empty() {
+        return None;
+    }
+    let mut lines: Vec<Option<f32>> = vec![None; n + 1];
+    let mut rows: Vec<DrawnRow> = Vec::new();
+    for b in boxes {
+        let g = t.grid_col(b.row, b.cell);
+        let span = t.rows.get(b.row).and_then(|r| r.cells.get(b.cell)).map_or(1, wordcraft_doc::Cell::span);
+        let end = g.saturating_add(span).min(n);
+        if let Some(x) = lines.get_mut(g) {
+            x.get_or_insert(b.rect.x);
+        }
+        if let Some(x) = lines.get_mut(end) {
+            x.get_or_insert(b.rect.right());
+        }
+        match rows.iter_mut().find(|r| r.row == b.row) {
+            Some(r) => {
+                r.top = r.top.min(b.rect.y);
+                r.bottom = r.bottom.max(b.rect.bottom());
+                r.edges.extend([g, end]);
+            }
+            None => rows.push(DrawnRow { row: b.row, top: b.rect.y, bottom: b.rect.bottom(), edges: vec![g, end] }),
+        }
+    }
+    // A line no cell on this page ends at: between its drawn neighbours, as the grid shares it.
+    let (first, last) = (lines.first().copied().flatten()?, lines.last().copied().flatten()?);
+    let weight = |i: usize| t.grid.get(i).copied().filter(|w| t.grid.len() == n && w.is_finite() && *w > 0.0).unwrap_or(1.0);
+    let mut cols = Vec::with_capacity(n + 1);
+    let mut prev = (0usize, first);
+    for i in 0..=n {
+        let x = match lines.get(i).copied().flatten() {
+            Some(x) => x,
+            None => {
+                let next = (i + 1..=n).find_map(|j| lines.get(j).copied().flatten().map(|x| (j, x))).unwrap_or((n, last));
+                let span: f32 = (prev.0..next.0).map(weight).sum();
+                let part: f32 = (prev.0..i).map(weight).sum();
+                prev.1 + (next.1 - prev.1) * if span > 0.0 { part / span } else { 0.0 }
+            }
+        };
+        let x = x.max(cols.last().copied().unwrap_or(x));
+        if lines.get(i).copied().flatten().is_some() {
+            prev = (i, x);
+        }
+        cols.push(x);
+    }
+    rows.sort_by_key(|r| r.row);
+    Some((cols, rows))
+}
+
+/// Every table drawn on a page, with its geometry there (`edge` is a placeholder).
+fn tables_on(l: &DocLayout, doc: &Document, page: usize) -> Vec<ResizeTarget> {
+    let boxes = cell_boxes(l, page);
+    let mut tables: Vec<(StoryRef, &Path)> = Vec::new();
+    for b in &boxes {
+        if !tables.iter().any(|(s, p)| *s == b.story && **p == b.table) {
+            tables.push((b.story, &b.table));
+        }
+    }
+    tables
+        .into_iter()
+        .filter_map(|(story, path)| {
+            let t = doc.table(story, path)?;
+            let mine: Vec<&CellBox> = boxes.iter().filter(|b| b.story == story && b.table == *path).collect();
+            let (cols, rows) = geometry(t, &mine)?;
+            let ends_here = rows.last().is_some_and(|r| r.row + 1 == t.rows.len());
+            Some(ResizeTarget { edge: Edge::Corner, story, table: path.clone(), cols, rows, ends_here })
+        })
+        .collect()
+}
+
+fn on_handle(t: &ResizeTarget, x: f32, y: f32, reach: f32) -> bool {
+    let h = t.handle();
+    t.ends_here && x >= h.x - reach / 2.0 && x <= h.right() + reach / 2.0 && y >= h.y - reach / 2.0 && y <= h.bottom() + reach / 2.0
+}
+
+/// The innermost table under page point (`x`, `y`) whose resize handle is on this page, or whose
+/// handle is under the point: the one whose handle the app shows.
+pub fn table_under(l: &DocLayout, doc: &Document, page: usize, x: f32, y: f32, reach: f32) -> Option<ResizeTarget> {
+    if !x.is_finite() || !y.is_finite() {
+        return None;
+    }
+    let reach = if reach.is_finite() { reach.clamp(0.5, 24.0) } else { REACH };
+    tables_on(l, doc, page)
+        .into_iter()
+        .filter(|t| t.ends_here && ((x >= t.left() && x <= t.right() && y >= t.top() && y <= t.bottom()) || on_handle(t, x, y, reach)))
+        .max_by_key(|t| t.table.0.len())
+}
+
+/// The table border or resize handle within `reach` points of page point (`x`, `y`): the
+/// nearest, and of nested tables the innermost.
+pub fn resize_target(l: &DocLayout, doc: &Document, page: usize, x: f32, y: f32, reach: f32) -> Option<ResizeTarget> {
+    if !x.is_finite() || !y.is_finite() {
+        return None;
+    }
+    let reach = if reach.is_finite() { reach.clamp(0.5, 24.0) } else { REACH };
+    let mut best: Option<(f32, usize, ResizeTarget)> = None;
+    for mut target in tables_on(l, doc, page) {
+        let depth = target.table.0.len();
+        let mut offer = |d: f32, edge: Edge, target: &mut ResizeTarget| {
+            if d <= reach && best.as_ref().is_none_or(|(bd, bdepth, _)| d < *bd - 0.01 || (d <= *bd + 0.01 && depth > *bdepth)) {
+                target.edge = edge;
+                best = Some((d, depth, target.clone()));
+            }
+        };
+        if on_handle(&target, x, y, reach) {
+            offer(0.0, Edge::Corner, &mut target);
+        }
+        let (left, right, top, bottom) = (target.left(), target.right(), target.top(), target.bottom());
+        if x < left - reach || x > right + reach || y < top - reach || y > bottom + reach {
+            continue;
+        }
+        // Column borders: in the row under the pointer, only lines that are cell borders there.
+        let row_here = target.rows.iter().find(|r| y >= r.top && y <= r.bottom).cloned();
+        if let Some(r) = &row_here {
+            for line in 1..target.cols.len() {
+                if r.edges.contains(&line)
+                    && let Some(cx) = target.cols.get(line).copied()
+                {
+                    offer((x - cx).abs(), Edge::Column(line), &mut target);
+                }
+            }
+        }
+        // Row borders: the bottom of each drawn row.
+        if x >= left && x <= right {
+            for r in target.rows.clone() {
+                offer((y - r.bottom).abs(), Edge::Row(r.row), &mut target);
+            }
+        }
+    }
+    best.map(|b| b.2)
+}
+
+fn resize_drag(s: &mut Session, v: &Value) -> CmdResult {
+    let page =
+        p::u64(v, "page").map(|n| usize::try_from(n).unwrap_or(usize::MAX)).ok_or_else(|| CmdError::Params("`page` (number) is required".into()))?;
+    let (x, y) = (p::req_f32(v, "x")?, p::req_f32(v, "y")?);
+    let (to_x, to_y) = (p::req_f32(v, "toX")?, p::req_f32(v, "toY")?);
+    let shift = p::bool(v, "shift").unwrap_or(false);
+    let reach = p::f32(v, "reach").unwrap_or(REACH);
+    let l = s.layout();
+    if l.pages.get(page).is_none() {
+        return Err(CmdError::Params(format!("no page {page}")));
+    }
+    let target =
+        resize_target(&l, &s.doc, page, x, y, reach).ok_or_else(|| CmdError::Failed("there's no table border or resize handle there".into()))?;
+    let plan = target.plan(to_x - x, to_y - y, shift);
+    if plan.widths.is_none() && plan.heights.is_empty() {
+        return sel_result(s);
+    }
+    let t = s.doc.table_mut(target.story, &target.table)?;
+    if let Some(widths) = plan.widths
+        && widths.len() == t.cols()
+    {
+        t.grid = widths;
+        // The drag's widths are the table's now: no preferred table width scales them again.
+        t.props.width = None;
+        t.props.width_pct = None;
+        super::table::sync_cell_widths(t);
+    }
+    for (r, h) in &plan.heights {
+        if let Some(row) = t.rows.get_mut(*r) {
+            row.props.height = Some(*h);
+            if row.props.height_rule != HeightRule::Exact {
+                row.props.height_rule = HeightRule::AtLeast;
+            }
+        }
+    }
+    touch(s, &target)?;
+    if plan.heights.is_empty() {
+        return sel_result(s);
+    }
+    // An "at least" height leaves out the cells' margins and border bands, which the layout adds
+    // (and which depend on the table style): measure what the rows came to and take the extra
+    // off once. A row its text holds taller keeps the dragged height.
+    let drawn = drawn_heights(&s.layout(), page, &target);
+    let mut fixed = Vec::new();
+    let t = s.doc.table_mut(target.story, &target.table)?;
+    for (r, want) in &plan.heights {
+        let Some(got) = drawn.iter().find(|(i, _)| i == r).map(|(_, h)| *h) else { continue };
+        if let Some(row) = t.rows.get_mut(*r)
+            && row.props.height_rule == HeightRule::AtLeast
+            && got > want + 0.05
+        {
+            row.props.height = Some((want - (got - want)).max(1.0));
+            fixed.push((*r, *want, got));
+        }
+    }
+    if fixed.is_empty() {
+        return sel_result(s);
+    }
+    touch(s, &target)?;
+    let again = drawn_heights(&s.layout(), page, &target);
+    let t = s.doc.table_mut(target.story, &target.table)?;
+    for (r, want, got) in fixed {
+        let now = again.iter().find(|(i, _)| *i == r).map_or(got, |(_, h)| *h);
+        if now >= got - 0.05
+            && let Some(row) = t.rows.get_mut(r)
+        {
+            row.props.height = Some(want);
+        }
+    }
+    touch(s, &target)?;
+    sel_result(s)
+}
+
+/// The drawn height of each of the target table's rows on `page`.
+fn drawn_heights(l: &DocLayout, page: usize, target: &ResizeTarget) -> Vec<(usize, f32)> {
+    let mut out: Vec<(usize, f32)> = Vec::new();
+    for b in cell_boxes(l, page).iter().filter(|b| b.story == target.story && b.table == target.table) {
+        match out.iter_mut().find(|(r, _)| *r == b.row) {
+            Some((_, h)) => *h = h.max(b.rect.h),
+            None => out.push((b.row, b.rect.h)),
+        }
+    }
+    out
+}
+
+/// Mark the table's paragraphs changed, so the layout redoes them.
+fn touch(s: &mut Session, target: &ResizeTarget) -> Result<(), CmdError> {
+    let story = target.story;
+    let paths: Vec<Path> =
+        s.doc.para_paths(story).into_iter().filter(|q| q.0.len() > target.table.0.len() && q.0.starts_with(&target.table.0)).collect();
+    for q in paths {
+        s.doc.para_mut(story, &q)?.touch();
+    }
+    // A new document revision: the next `layout()` lays the change out instead of reusing the
+    // cached pages.
+    s.touch();
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    fn first_table(s: &Session) -> Table {
+        s.doc.body.iter().find_map(|b| b.as_table()).cloned().unwrap()
+    }
+
+    fn cell_rect(s: &mut Session, row: usize, cell: usize) -> Rect {
+        s.layout().pages[0]
+            .items
+            .iter()
+            .find_map(|it| match it {
+                Placed::Cell { rect, row: r, cell: c, .. } if *r == row && *c == cell => Some(*rect),
+                _ => None,
+            })
+            .unwrap()
+    }
+
+    fn table_session(rows: usize, cols: usize) -> Session {
+        let mut s = Session::new(wordcraft_doc::Document::new());
+        s.run("insert.table", &json!({"rows": rows, "cols": cols})).unwrap();
+        s
+    }
+
+    /// Dragging the border between two columns moves it; the right neighbour gives up the room,
+    /// so the table keeps its width; one undo puts it back.
+    #[test]
+    fn a_column_border_drag_trades_width_with_the_neighbour() {
+        let mut s = table_session(2, 3);
+        let start = first_table(&s);
+        let a = cell_rect(&mut s, 0, 0);
+        let (b0, total0) = (cell_rect(&mut s, 0, 1), cell_rect(&mut s, 0, 2).right() - a.x);
+        let y = a.y + a.h / 2.0;
+        s.run("table.resizeDrag", &json!({"page": 0, "x": a.right() + 1.0, "y": y, "toX": a.right() + 31.0, "toY": y})).unwrap();
+        let (a1, b1) = (cell_rect(&mut s, 0, 0), cell_rect(&mut s, 0, 1));
+        assert!((a1.w - (a.w + 30.0)).abs() < 1.0, "{a:?} → {a1:?}");
+        assert!((b1.w - (b0.w - 30.0)).abs() < 1.0, "{b0:?} → {b1:?}");
+        let total1 = cell_rect(&mut s, 0, 2).right() - a1.x;
+        assert!((total1 - total0).abs() < 1.0, "the table keeps its width");
+        // The second row follows: one border for the whole column.
+        assert!((cell_rect(&mut s, 1, 0).w - a1.w).abs() < 0.5);
+        s.run("edit.undo", &json!({})).unwrap();
+        assert_eq!(first_table(&s), start, "one undo step");
+    }
+
+    /// With Shift only the left column changes and the table grows; the right edge does the same.
+    #[test]
+    fn shift_and_the_right_edge_change_the_table_width() {
+        let mut s = table_session(1, 2);
+        let (a, b) = (cell_rect(&mut s, 0, 0), cell_rect(&mut s, 0, 1));
+        let y = a.y + a.h / 2.0;
+        s.run("table.resizeDrag", &json!({"page": 0, "x": a.right(), "y": y, "toX": a.right() - 40.0, "toY": y, "shift": true})).unwrap();
+        let (a1, b1) = (cell_rect(&mut s, 0, 0), cell_rect(&mut s, 0, 1));
+        assert!((a1.w - (a.w - 40.0)).abs() < 1.0 && (b1.w - b.w).abs() < 1.0, "{a1:?} {b1:?}");
+        s.run("table.resizeDrag", &json!({"page": 0, "x": b1.right() - 1.0, "y": y, "toX": b1.right() - 51.0, "toY": y})).unwrap();
+        let b2 = cell_rect(&mut s, 0, 1);
+        assert!((b2.w - (b1.w - 50.0)).abs() < 1.0, "{b1:?} → {b2:?}");
+    }
+
+    /// No column gets narrower than the minimum, however far the drag goes.
+    #[test]
+    fn column_drags_stop_at_the_minimum_width() {
+        let mut s = table_session(1, 2);
+        let (a, b) = (cell_rect(&mut s, 0, 0), cell_rect(&mut s, 0, 1));
+        let y = a.y + a.h / 2.0;
+        s.run("table.resizeDrag", &json!({"page": 0, "x": a.right(), "y": y, "toX": a.right() + 5000.0, "toY": y})).unwrap();
+        let t = first_table(&s);
+        assert!((t.grid[1] - MIN_COL).abs() < 0.01, "{:?}", t.grid);
+        assert!((t.grid[0] + t.grid[1] - (a.w + b.w)).abs() < 1.0);
+    }
+
+    /// Dragging a row's bottom border sets its height ("at least"), and the row grows.
+    #[test]
+    fn a_row_border_drag_sets_the_row_height() {
+        let mut s = table_session(2, 2);
+        let a = cell_rect(&mut s, 0, 0);
+        let x = a.x + a.w / 2.0;
+        s.run("table.resizeDrag", &json!({"page": 0, "x": x, "y": a.bottom() + 1.0, "toX": x, "toY": a.bottom() + 41.0})).unwrap();
+        let t = first_table(&s);
+        assert_eq!(t.rows[0].props.height_rule, HeightRule::AtLeast);
+        // The stored height leaves out the margins and borders; the drawn row is what was dragged.
+        assert!(t.rows[0].props.height.unwrap() < a.h + 40.0, "{:?}", t.rows[0].props);
+        let h = cell_rect(&mut s, 0, 0).h;
+        assert!((h - (a.h + 40.0)).abs() < 0.1, "{} → {h}", a.h);
+        assert_eq!(t.rows[1].props.height, None, "the other row is untouched");
+    }
+
+    /// The handle past the bottom-right corner scales every column and row.
+    #[test]
+    fn the_corner_handle_scales_the_table() {
+        let mut s = table_session(2, 2);
+        let (a, d) = (cell_rect(&mut s, 0, 0), cell_rect(&mut s, 1, 1));
+        let (w, h) = (d.right() - a.x, d.bottom() - a.y);
+        let (hx, hy) = (d.right() + 1.0 + HANDLE / 2.0, d.bottom() + 1.0 + HANDLE / 2.0);
+        let l = s.layout();
+        let tgt = resize_target(&l, &s.doc, 0, hx, hy, REACH).unwrap();
+        assert_eq!(tgt.edge, Edge::Corner);
+        // Half as wide, twice as tall: the handle moves by that much.
+        s.run("table.resizeDrag", &json!({"page": 0, "x": hx, "y": hy, "toX": hx - w * 0.5, "toY": hy + h})).unwrap();
+        let (a1, d1) = (cell_rect(&mut s, 0, 0), cell_rect(&mut s, 1, 1));
+        assert!(((d1.right() - a1.x) - w * 0.5).abs() < 1.5, "{w} → {}", d1.right() - a1.x);
+        assert!(((d1.bottom() - a1.y) - h * 2.0).abs() < 0.5, "{h} → {}", d1.bottom() - a1.y);
+    }
+
+    /// A merged cell hides the border it covers: no column border to grab in its middle.
+    #[test]
+    fn merged_cells_have_no_border_inside() {
+        let mut s = table_session(2, 2);
+        let a = cell_rect(&mut s, 0, 0);
+        s.run("table.eraser", &json!({"page": 0, "x": a.right(), "y": a.y + a.h / 2.0})).unwrap();
+        let l = s.layout();
+        let m = cell_rect(&mut s, 0, 0);
+        let mid = resize_target(&l, &s.doc, 0, a.right(), m.y + m.h / 2.0, REACH);
+        assert!(mid.as_ref().is_none_or(|t| t.edge != Edge::Column(1)), "{mid:?}");
+        // The second row still has it.
+        let b = cell_rect(&mut s, 1, 0);
+        let t = resize_target(&l, &s.doc, 0, b.right(), b.y + b.h / 2.0, REACH).unwrap();
+        assert_eq!(t.edge, Edge::Column(1));
+    }
+
+    /// Away from any border, or with hostile numbers: an error and no change, never a panic.
+    #[test]
+    fn misses_and_hostile_params_change_nothing() {
+        let mut s = table_session(2, 2);
+        let start = first_table(&s);
+        let c = cell_rect(&mut s, 0, 0);
+        let mid = json!({"page": 0, "x": c.x + c.w / 2.0, "y": c.y + c.h / 2.0, "toX": 10, "toY": 10});
+        assert!(s.run("table.resizeDrag", &mid).is_err());
+        assert!(s.run("table.resizeDrag", &json!({"page": 0, "x": 1e30, "y": -1e30, "toX": 1e30, "toY": 1e30})).is_err());
+        assert!(s.run("table.resizeDrag", &json!({"page": 99, "x": 1, "y": 1, "toX": 1, "toY": 1})).is_err());
+        assert!(s.run("table.resizeDrag", &json!({})).is_err());
+        let y = c.y + c.h / 2.0;
+        s.run("table.resizeDrag", &json!({"page": 0, "x": c.right(), "y": y, "toX": f32::MAX, "toY": y, "reach": 1e9})).unwrap();
+        assert!(first_table(&s).grid.iter().all(|w| w.is_finite() && *w >= MIN_COL));
+        s.run("edit.undo", &json!({})).unwrap();
+        assert_eq!(first_table(&s), start);
+    }
+}
diff --git a/crates/engine/src/cmd/templates.rs b/crates/engine/src/cmd/templates.rs
new file mode 100644
index 0000000000..f8033d07ac
--- /dev/null
+++ b/crates/engine/src/cmd/templates.rs
@@ -0,0 +1,513 @@
+//! Tools › Templates and Add-ins: the template a document is attached to, updating the
+//! document's styles from it, and the Organizer (copy styles from another document or template,
+//! delete and rename styles in this one).
+//!
+//! The attached template is kept as the file gives it (`w:attachedTemplate`, ECMA-376 Part 1
+//! §17.15.1.6), and "Automatically update document styles" is `w:linkStyles` (§17.15.1.56).
+//! The template path comes from the document, so it is never read on its own (not on open
+//! either): only an explicit `tools.updateStyles` or `tools.attachTemplate` with `update` reads it.
+
+use std::collections::{HashMap, HashSet};
+use std::path::{Path, PathBuf};
+
+use serde_json::{Value, json};
+use wordcraft_doc::Document;
+use wordcraft_doc::numbering::{AbstractNum, Num};
+use wordcraft_doc::styles::{Style, StyleKind};
+
+use super::para::touch_all;
+use crate::{CmdError, CmdResult, CommandSpec, Session, p};
+
+/// Longest template path or style name list we take from params.
+const MAX_PATH: usize = 32 * 1024;
+/// Most styles one copy takes (with the styles they are based on).
+const MAX_COPY: usize = 10_000;
+/// Longest style name (Word's limit).
+const MAX_NAME: usize = 253;
+
+pub fn specs() -> Vec<CommandSpec> {
+    const LOC: &str = "View › Templates › Templates and Add-ins";
+    vec![
+        CommandSpec::new("tools.templates", "Templates and Add-ins", "View › Templates", |s, _| Ok(state(s)))
+            .params(r#"{} → {"template": path|null, "linkStyles": bool} (from the ribbon, the app shows the dialog)"#)
+        .pure(),
+        CommandSpec::new("tools.attachTemplate", "Attach Template", LOC, attach)
+            .params(r#"{"path": string, "linkStyles"?: bool, "update"?: bool (update the styles from it now), "data"?: base64 (the template's bytes, for "update")}"#),
+        CommandSpec::new("tools.detachTemplate", "Detach Template", LOC, |s, _| {
+            s.doc.settings.attached_template = None;
+            s.doc.settings.link_styles = false;
+            Ok(state(s))
+        }),
+        CommandSpec::new("tools.linkStyles", "Automatically Update Document Styles", LOC, |s, v| {
+            s.doc.settings.link_styles = p::bool(v, "value").unwrap_or(!s.doc.settings.link_styles);
+            Ok(state(s))
+        })
+        .params(r#"{"value"?: bool (default: toggle)}"#),
+        CommandSpec::new("tools.updateStyles", "Update Styles from Template", LOC, update_styles)
+            .params(r#"{"path"?: string (default: the attached template), "data"?: base64 (the file's bytes; `path` then only names it)} → {"added", "replaced"}"#),
+        CommandSpec::new("styles.organizer", "Organizer", "View › Templates › Organizer", organizer)
+            .params(r#"{"path"?: string, "data"?: base64} → {"document": [style], "file"?: {"path", "styles": [style]}}"#)
+            .pure(),
+        CommandSpec::new("styles.copyFrom", "Copy Styles", "View › Templates › Organizer", copy_from)
+            .params(r#"{"path": string, "data"?: base64, "styles": [name or id]} → {"added", "replaced", "skipped"}"#),
+        CommandSpec::new("styles.rename", "Rename Style", "View › Templates › Organizer", rename)
+            .params(r#"{"style": string (name or id; custom styles only), "name": string}"#),
+    ]
+}
+
+fn state(s: &Session) -> Value {
+    json!({"template": s.doc.settings.attached_template, "linkStyles": s.doc.settings.link_styles})
+}
+
+fn attach(s: &mut Session, v: &Value) -> CmdResult {
+    let path = p::req_str(v, "path")?.trim();
+    if path.is_empty() {
+        return Err(CmdError::Params("`path` is empty".into()));
+    }
+    if path.len() > MAX_PATH {
+        return Err(CmdError::Params("`path` is too long".into()));
+    }
+    let path = path.to_string();
+    s.doc.settings.attached_template = Some(path.clone());
+    if let Some(on) = p::bool(v, "linkStyles") {
+        s.doc.settings.link_styles = on;
+    }
+    let mut out = state(s);
+    if p::bool(v, "update").unwrap_or(false) {
+        let mut params = json!({"path": path});
+        if let (Some(d), Some(o)) = (p::str(v, "data"), params.as_object_mut()) {
+            o.insert("data".into(), json!(d));
+        }
+        let r = update_styles(s, &params)?;
+        if let Some(o) = out.as_object_mut() {
+            o.insert("updated".into(), r);
+        }
+    }
+    Ok(out)
+}
+
+/// Copy every style of the template (and its document defaults) into the document, replacing
+/// styles of the same name.
+fn update_styles(s: &mut Session, v: &Value) -> CmdResult {
+    let attached = s.doc.settings.attached_template.clone();
+    let path = p::str(v, "path").map(str::to_string).or(attached).ok_or_else(|| CmdError::Params("no template is attached; give `path`".into()))?;
+    let base = s.path.clone();
+    let src = load_other(&path, p::str(v, "data"), base.as_deref())?;
+    let report = apply_template_styles(&mut s.doc, &src);
+    touch_all(s);
+    Ok(report)
+}
+
+/// What [`update_styles`] does to a document: all of `src`'s styles and its defaults.
+pub fn apply_template_styles(doc: &mut Document, src: &Document) -> Value {
+    doc.styles.default_chr = src.styles.default_chr.clone();
+    doc.styles.default_para = src.styles.default_para.clone();
+    let ids: Vec<String> = src.styles.styles.iter().map(|st| st.id.clone()).collect();
+    copy_styles(doc, src, &ids)
+}
+
+fn organizer(s: &mut Session, v: &Value) -> CmdResult {
+    let mut out = json!({"document": style_list(&s.doc)});
+    if let Some(path) = p::str(v, "path") {
+        let base = s.path.clone();
+        let other = load_other(path, p::str(v, "data"), base.as_deref())?;
+        if let Some(o) = out.as_object_mut() {
+            o.insert("file".into(), json!({"path": path, "styles": style_list(&other)}));
+        }
+    }
+    Ok(out)
+}
+
+/// A document's styles for the Organizer, by name: `[{id, name, type, builtIn}]`.
+pub fn style_list(doc: &Document) -> Value {
+    let mut list: Vec<&Style> = doc.styles.styles.iter().collect();
+    list.sort_by_cached_key(|st| st.name.to_lowercase());
+    Value::Array(
+        list.iter()
+            .map(|st| {
+                let kind = match st.kind {
+                    StyleKind::Paragraph => "paragraph",
+                    StyleKind::Character => "character",
+                    StyleKind::Table => "table",
+                    StyleKind::Numbering => "numbering",
+                };
+                json!({"id": st.id, "name": st.name, "type": kind, "builtIn": st.builtin})
+            })
+            .collect(),
+    )
+}
+
+fn copy_from(s: &mut Session, v: &Value) -> CmdResult {
+    let path = p::req_str(v, "path")?;
+    let names: Vec<&str> = match v.get("styles") {
+        Some(Value::Array(a)) => a.iter().filter_map(Value::as_str).take(MAX_COPY).collect(),
+        Some(Value::String(one)) => vec![one.as_str()],
+        _ => return Err(CmdError::Params("`styles` (list of style names) is required".into())),
+    };
+    if names.is_empty() {
+        return Err(CmdError::Params("`styles` is empty".into()));
+    }
+    let base = s.path.clone();
+    let src = load_other(path, p::str(v, "data"), base.as_deref())?;
+    let mut ids = Vec::new();
+    for n in names {
+        let st = src.styles.find(n).ok_or_else(|| CmdError::Params(format!("`{path}` has no style `{n}`")))?;
+        ids.push(st.id.clone());
+    }
+    let report = copy_styles(&mut s.doc, &src, &ids);
+    touch_all(s);
+    Ok(report)
+}
+
+fn rename(s: &mut Session, v: &Value) -> CmdResult {
+    let which = p::req_str(v, "style")?;
+    let name = p::req_str(v, "name")?.trim().to_string();
+    if name.is_empty() || name.chars().count() > MAX_NAME {
+        return Err(CmdError::Params(format!("a style name has 1 to {MAX_NAME} characters")));
+    }
+    let st = s.doc.styles.find(which).cloned().ok_or_else(|| CmdError::Params(format!("no style `{which}`")))?;
+    if st.builtin {
+        return Err(CmdError::Failed(format!("`{}` is a built-in style and can't be renamed", st.name)));
+    }
+    if s.doc.styles.styles.iter().any(|o| o.id != st.id && o.name.eq_ignore_ascii_case(&name)) {
+        return Err(CmdError::Failed(format!("a style named `{name}` already exists")));
+    }
+    if let Some(x) = s.doc.styles.get_mut(&st.id) {
+        x.name = name.clone();
+    }
+    touch_all(s);
+    Ok(json!({"id": st.id, "name": name}))
+}
+
+/// Read another document or template: from `data` (base64 bytes, `name` gives the format) or
+/// from the file `name` names (a path or `file:` URL; relative to `base`'s folder).
+fn load_other(name: &str, data: Option<&str>, base: Option<&Path>) -> Result<Document, CmdError> {
+    if name.len() > MAX_PATH {
+        return Err(CmdError::Params("`path` is too long".into()));
+    }
+    let local = local_path(name, base).ok_or_else(|| CmdError::Failed(format!("`{name}` is not a local file")))?;
+    let ext = local.extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default();
+    if matches!(ext.as_str(), "" | "txt" | "text") {
+        return Err(CmdError::Params(format!("`{name}` is not a document or template with styles")));
+    }
+    match data {
+        Some(d) => {
+            let bytes = super::insert::base64_decode(d).ok_or_else(|| CmdError::Params("bad base64".into()))?;
+            crate::io::open_bytes(&local.to_string_lossy(), &bytes).map_err(CmdError::Failed)
+        }
+        None => crate::io::open_path(&local).map_err(CmdError::Failed),
+    }
+}
+
+/// A template reference as a local path: a `file:` URL (percent-encoded) becomes a path, a
+/// relative path is taken from `base`'s folder. Other URLs (`http:`…) are `None`.
+pub fn local_path(target: &str, base: Option<&Path>) -> Option<PathBuf> {
+    let t = target.trim();
+    let lower = t.to_ascii_lowercase();
+    let path = if lower.starts_with("file:") {
+        let rest = percent_decode(t.get(5..)?);
+        let rest = match rest.strip_prefix("//") {
+            // `file:///x` and `file://localhost/x` are local; `file://host/share/x` names another machine.
+            Some(r) if r.starts_with('/') => r.to_string(),
+            Some(r) if r.len() >= 10 && r.get(..10).is_some_and(|h| h.eq_ignore_ascii_case("localhost/")) => r.get(9..)?.to_string(),
+            Some(_) => return None,
+            None => rest,
+        };
+        // `file:///C:/x` → `C:/x`.
+        let b = rest.as_bytes();
+        if b.first() == Some(&b'/') && b.get(1).is_some_and(u8::is_ascii_alphabetic) && b.get(2) == Some(&b':') {
+            rest.get(1..)?.to_string()
+        } else {
+            rest
+        }
+    } else if t.contains("://") {
+        return None;
+    } else {
+        t.to_string()
+    };
+    // Never follow a template path to another machine: opening `\\host\share\T.dotx` (or `//host/…`) from a
+    // hostile document would make Windows authenticate to that host and leak the user's NTLM credentials.
+    if path.is_empty() || is_network_path(&path) {
+        return None;
+    }
+    let p = PathBuf::from(&path);
+    if p.is_relative()
+        && !is_windows_absolute(&path)
+        && let Some(dir) = base.and_then(Path::parent)
+    {
+        return Some(dir.join(p));
+    }
+    Some(p)
+}
+
+fn is_network_path(p: &str) -> bool {
+    let b = p.as_bytes();
+    matches!((b.first(), b.get(1)), (Some(b'\\' | b'/'), Some(b'\\' | b'/')))
+}
+
+fn is_windows_absolute(p: &str) -> bool {
+    let b = p.as_bytes();
+    p.starts_with("\\\\") || (b.first().is_some_and(u8::is_ascii_alphabetic) && b.get(1) == Some(&b':'))
+}
+
+fn percent_decode(s: &str) -> String {
+    let hex = |c: u8| (c as char).to_digit(16).and_then(|d| u8::try_from(d).ok());
+    let mut out = Vec::with_capacity(s.len());
+    let mut it = s.bytes();
+    while let Some(c) = it.next() {
+        if c != b'%' {
+            out.push(c);
+            continue;
+        }
+        let rest = it.clone();
+        match (it.next().and_then(hex), it.next().and_then(hex)) {
+            (Some(h), Some(l)) => out.push((h << 4) | l),
+            _ => {
+                out.push(b'%');
+                it = rest;
+            }
+        }
+    }
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+/// Copy styles `ids` of `src` into `doc`, Organizer-style: a style replaces the document's style
+/// of the same name (and kind), or is added (under its own id when that is free). The styles they
+/// are based on that the document lacks, and their linked halves, come too; `based on`, `next`
+/// and `linked` are mapped to the document's ids, and lists a style numbers with are copied.
+/// Returns `{"added": [name], "replaced": [name], "skipped": [name]}`.
+pub fn copy_styles(doc: &mut Document, src: &Document, ids: &[String]) -> Value {
+    let sheet = &src.styles;
+    let same_name = |doc: &Document, st: &Style| doc.styles.styles.iter().find(|d| d.name.eq_ignore_ascii_case(&st.name)).map(|d| d.id.clone());
+    // What to copy: the asked-for styles, their linked halves, and missing bases.
+    let mut want: Vec<String> = Vec::new();
+    let mut seen: HashSet<String> = HashSet::new();
+    let mut queue: Vec<String> = ids.iter().rev().cloned().collect();
+    while let Some(id) = queue.pop() {
+        if want.len() >= MAX_COPY {
+            break;
+        }
+        if !seen.insert(id.clone()) {
+            continue;
+        }
+        let Some(st) = sheet.get(&id) else { continue };
+        want.push(id.clone());
+        if let Some(l) = st.linked.as_deref()
+            && sheet.get(l).is_some_and(|x| x.linked.as_deref() == Some(st.id.as_str()))
+        {
+            queue.push(l.to_string());
+        }
+        if let Some(b) = st.based_on.as_deref()
+            && let Some(base) = sheet.get(b)
+            && same_name(doc, base).is_none()
+        {
+            queue.push(b.to_string());
+        }
+    }
+    // Ids in the document, in `src` order.
+    let mut map: HashMap<String, String> = HashMap::new();
+    let mut order: Vec<(String, String)> = Vec::new();
+    let (mut added, mut replaced, mut skipped) = (Vec::new(), Vec::new(), Vec::new());
+    let want: HashSet<String> = want.into_iter().collect();
+    for st in sheet.styles.iter().filter(|st| want.contains(&st.id)) {
+        let target = match same_name(doc, st) {
+            Some(existing) => {
+                if doc.styles.get(&existing).is_some_and(|d| d.kind != st.kind) {
+                    skipped.push(st.name.clone());
+                    continue;
+                }
+                replaced.push(st.name.clone());
+                existing
+            }
+            None => {
+                added.push(st.name.clone());
+                if doc.styles.get(&st.id).is_none() { st.id.clone() } else { doc.styles.new_id(&st.name) }
+            }
+        };
+        let builtin = doc.styles.get(&target).is_some_and(|d| d.builtin) || st.builtin;
+        doc.styles.upsert(Style { id: target.clone(), builtin, ..st.clone() });
+        map.insert(st.id.clone(), target.clone());
+        order.push((st.id.clone(), target));
+    }
+    // References to `src` ids → the document's ids (copied styles, or same-named ones).
+    let resolve = |doc: &Document, map: &HashMap<String, String>, r: &str| -> Option<String> {
+        map.get(r).cloned().or_else(|| sheet.get(r).and_then(|st| same_name(doc, st)))
+    };
+    let mut nums: HashMap<u32, u32> = HashMap::new();
+    for (src_id, target) in order {
+        let Some(st) = sheet.get(&src_id) else { continue };
+        let based_on = st.based_on.as_deref().and_then(|r| resolve(doc, &map, r)).filter(|b| *b != target);
+        let next = st.next.as_deref().and_then(|r| resolve(doc, &map, r));
+        let linked = st.linked.as_deref().and_then(|r| map.get(r).cloned());
+        let numbering = st.para.numbering.map(|mut n| {
+            if n.num != 0 {
+                n.num = import_num(doc, src, n.num, &map, &mut nums).unwrap_or(0);
+            }
+            n
+        });
+        if let Some(d) = doc.styles.get_mut(&target) {
+            d.based_on = based_on;
+            d.next = next;
+            d.linked = linked;
+            d.para.numbering = numbering.filter(|n| n.num != 0 || st.para.numbering.is_some_and(|o| o.num == 0));
+        }
+    }
+    json!({"added": added, "replaced": replaced, "skipped": skipped})
+}
+
+/// Copy list `num` of `src` (and its abstract list) into `doc` under new ids; memoised in `done`.
+fn import_num(doc: &mut Document, src: &Document, num: u32, map: &HashMap<String, String>, done: &mut HashMap<u32, u32>) -> Option<u32> {
+    if let Some(n) = done.get(&num) {
+        return Some(*n);
+    }
+    let n = src.numbering.nums.iter().find(|n| n.id == num)?;
+    let abs = src.numbering.abstracts.iter().find(|a| a.id == n.abstract_id)?;
+    let new_abs = doc.numbering.abstracts.iter().map(|a| a.id).max().map_or(Some(0), |m| m.checked_add(1))?;
+    let new_num = doc.numbering.nums.iter().map(|n| n.id).max().map_or(Some(1), |m| m.checked_add(1))?;
+    let mut levels = abs.levels.clone();
+    for l in &mut levels {
+        l.style = l.style.as_deref().and_then(|s| map.get(s).cloned().or_else(|| doc.styles.get(s).map(|x| x.id.clone())));
+    }
+    doc.numbering.abstracts.push(AbstractNum { id: new_abs, name: abs.name.clone(), levels });
+    doc.numbering.nums.push(Num { id: new_num, abstract_id: new_abs, ..n.clone() });
+    done.insert(num, new_num);
+    Some(new_num)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use wordcraft_doc::numbering::ListKind;
+    use wordcraft_doc::props::{CharProps, NumRef};
+
+    /// A template built in code: a changed Heading 1, a custom "Callout" based on a custom
+    /// "Box" (missing in the document) and a numbered "Steps" style.
+    fn template() -> Document {
+        let mut t = Document::new();
+        if let Some(h) = t.styles.get_mut("Heading1") {
+            h.chr.size = Some(31.0);
+        }
+        t.styles.upsert(Style {
+            id: "Box".into(),
+            name: "Box".into(),
+            kind: StyleKind::Paragraph,
+            based_on: Some("Normal".into()),
+            ..Default::default()
+        });
+        t.styles.upsert(Style {
+            id: "Callout".into(),
+            name: "Callout".into(),
+            kind: StyleKind::Paragraph,
+            based_on: Some("Box".into()),
+            chr: CharProps { italic: Some(true), ..Default::default() },
+            ..Default::default()
+        });
+        let num = t.numbering.add_list(ListKind::Numbered);
+        t.styles.upsert(Style {
+            id: "Steps".into(),
+            name: "Steps".into(),
+            kind: StyleKind::Paragraph,
+            para: wordcraft_doc::props::ParaProps { numbering: Some(NumRef { num, level: 0 }), ..Default::default() },
+            ..Default::default()
+        });
+        t
+    }
+
+    fn save(name: &str, doc: &Document) -> PathBuf {
+        let dir = std::env::temp_dir().join(format!("wordcraft-templates-{name}-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("Report.dotx");
+        crate::io::save_path(&path, doc).unwrap();
+        path
+    }
+
+    #[test]
+    fn update_styles_from_template_is_one_undo_step() {
+        let path = save("update", &template());
+        let mut s = Session::new(Document::new());
+        s.run("tools.attachTemplate", &json!({"path": path.to_string_lossy()})).unwrap();
+        assert_eq!(s.doc.settings.attached_template.as_deref(), Some(path.to_string_lossy().as_ref()));
+        let before = s.doc.styles.clone();
+        let r = s.run("tools.updateStyles", &json!({})).unwrap();
+        assert!(r["replaced"].as_array().unwrap().iter().any(|n| n == "heading 1" || n == "Heading 1"), "{r}");
+        assert_eq!(s.doc.styles.get("Heading1").unwrap().chr.size, Some(31.0));
+        let callout = s.doc.styles.get("Callout").unwrap();
+        assert_eq!(callout.based_on.as_deref(), Some("Box"), "the missing base came along");
+        let steps = s.doc.styles.get("Steps").unwrap().para.numbering.unwrap();
+        assert!(s.doc.numbering.nums.iter().any(|n| n.id == steps.num), "the style's list was copied");
+        s.run("edit.undo", &json!({})).unwrap();
+        assert_eq!(s.doc.styles, before);
+        // A missing template is an error, not a crash, and changes nothing.
+        let err = s.run("tools.updateStyles", &json!({"path": "/nonexistent/x.dotx"}));
+        assert!(err.is_err());
+        assert_eq!(s.doc.styles, before);
+        let _ = std::fs::remove_dir_all(path.parent().unwrap());
+    }
+
+    #[test]
+    fn organizer_copies_renames_and_undoes() {
+        let path = save("organizer", &template());
+        let p = path.to_string_lossy().to_string();
+        let mut s = Session::new(Document::new());
+        let listed = s.run("styles.organizer", &json!({"path": p})).unwrap();
+        assert!(listed["file"]["styles"].as_array().unwrap().iter().any(|x| x["name"] == "Callout"));
+        let r = s.run("styles.copyFrom", &json!({"path": p, "styles": ["Callout"]})).unwrap();
+        assert_eq!(r["added"], json!(["Box", "Callout"]));
+        assert_eq!(s.doc.styles.get("Callout").unwrap().chr.italic, Some(true));
+        s.run("styles.rename", &json!({"style": "Callout", "name": "Aside"})).unwrap();
+        assert_eq!(s.doc.styles.find("Aside").map(|x| x.id.as_str()), Some("Callout"));
+        assert!(s.run("styles.rename", &json!({"style": "Normal", "name": "Plain"})).is_err(), "built-in styles keep their names");
+        assert!(s.run("styles.rename", &json!({"style": "Aside", "name": "Box"})).is_err(), "names stay unique");
+        s.run("edit.undo", &json!({})).unwrap();
+        assert!(s.doc.styles.find("Callout").is_some());
+        s.run("edit.undo", &json!({})).unwrap();
+        assert!(s.doc.styles.get("Callout").is_none() && s.doc.styles.get("Box").is_none());
+        let _ = std::fs::remove_dir_all(path.parent().unwrap());
+    }
+
+    /// The template path comes from the document, so opening never reads it, even with
+    /// "Automatically update document styles" on: only an explicit `tools.updateStyles` does.
+    #[test]
+    fn opening_a_linked_document_never_reads_its_template() {
+        let path = save("open", &template());
+        let mut d = Document::new();
+        d.settings.attached_template = Some("Report.dotx".into());
+        d.settings.link_styles = true;
+        let doc_path = path.with_file_name("Letter.docx");
+        crate::io::save_path(&doc_path, &d).unwrap();
+        let mut s = Session::new(Document::new());
+        s.run("file.open", &json!({"path": doc_path.to_string_lossy()})).unwrap();
+        assert_eq!(s.doc.settings.attached_template.as_deref(), Some("Report.dotx"), "the reference is kept");
+        assert!(s.doc.settings.link_styles);
+        assert_ne!(s.doc.styles.get("Heading1").unwrap().chr.size, Some(31.0), "the template's styles were not read");
+        assert!(s.doc.styles.get("Callout").is_none());
+        assert!(!s.dirty);
+        // The user's explicit update reads it (relative to the document's folder).
+        s.run("tools.updateStyles", &json!({})).unwrap();
+        assert_eq!(s.doc.styles.get("Heading1").unwrap().chr.size, Some(31.0));
+        let _ = std::fs::remove_dir_all(path.parent().unwrap());
+    }
+
+    #[test]
+    fn template_references_become_local_paths() {
+        assert_eq!(local_path("file:///C:/Users/A%20B/T.dotx", None), Some(PathBuf::from("C:/Users/A B/T.dotx")));
+        assert_eq!(local_path("file:///home/a/T.dotx", None), Some(PathBuf::from("/home/a/T.dotx")));
+        assert_eq!(local_path("https://example.com/T.dotx", None), None);
+        assert_eq!(local_path("T.dotx", Some(Path::new("/docs/Letter.docx"))), Some(PathBuf::from("/docs/T.dotx")));
+        assert_eq!(local_path("file://localhost/home/a/T.dotx", None), Some(PathBuf::from("/home/a/T.dotx")));
+        // A hostile document must not send us to another machine (NTLM credential leak over SMB on Windows).
+        for remote in [
+            "\\\\evil.example\\share\\T.dotx",
+            "//evil.example/share/T.dotx",
+            "\\\\?\\UNC\\evil.example\\share\\T.dotx",
+            "file://evil.example/share/T.dotx",
+            "file:////evil.example/share/T.dotx",
+            "FILE://Evil.Example/T.dotx",
+        ] {
+            assert_eq!(local_path(remote, Some(Path::new("/docs/Letter.docx"))), None, "{remote}");
+        }
+        assert_eq!(percent_decode("100%"), "100%");
+        assert_eq!(percent_decode("%zz%4"), "%zz%4");
+    }
+}
diff --git a/crates/engine/src/cmd/text.rs b/crates/engine/src/cmd/text.rs
index 2725c83a96..3eb42a7bca 100644
--- a/crates/engine/src/cmd/text.rs
+++ b/crates/engine/src/cmd/text.rs
@@ -1,9 +1,9 @@
 //! Typing and deleting.
 
 use serde_json::Value;
-use wordcraft_doc::para::{COLUMN_BREAK, NB_HYPHEN, NBSP, PAGE_BREAK, SOFT_HYPHEN};
+use wordcraft_doc::para::{COLUMN_BREAK, NB_HYPHEN, NBSP, OBJ, PAGE_BREAK, SOFT_HYPHEN};
 use wordcraft_doc::props::{Border, BorderStyle, NumRef};
-use wordcraft_doc::{Block, ListKind, Pos};
+use wordcraft_doc::{Block, ListKind, Path, Pos, StoryRef, Table};
 
 use super::{delete_selection, non_mac, sel_result, split_para, type_text};
 use crate::{CmdError, CmdResult, CommandSpec, Selection, Session, p};
@@ -45,6 +45,9 @@ fn autoformat(s: &mut Session, text: &str) -> Option<String> {
         return None;
     }
     let c = text.chars().next()?;
+    if !s.prefs.autocorrect.enabled || !s.prefs.autocorrect.smart_quotes {
+        return None;
+    }
     let f = &s.sel.focus;
     let para = s.doc.para_at(f)?;
     let before = para.text.get(..f.off)?;
@@ -57,9 +60,35 @@ fn autoformat(s: &mut Session, text: &str) -> Option<String> {
     }
 }
 
+/// File › Options › Advanced before typed text goes in: with "Typing replaces selected text"
+/// off the text goes in front of the selection and leaves it; in overtype the text replaces as
+/// many characters after the caret as it has, up to the paragraph's end or an object (picture,
+/// field), which stay.
+fn typing_options(s: &mut Session, text: &str) {
+    if !s.sel.is_collapsed() {
+        if !s.prefs.typing_replaces_selection {
+            let (start, _) = s.sel.ordered();
+            s.sel = Selection::caret(start);
+        }
+        return;
+    }
+    if !s.prefs.overtype || text.contains(['\r', '\n', '\u{2029}', '\u{000B}']) {
+        return;
+    }
+    let f = s.sel.focus.clone();
+    let Some(rest) = s.doc.para_at(&f).and_then(|p| p.text.get(f.off..)) else { return };
+    let n = text.chars().count();
+    let len: usize = rest.chars().take(n).take_while(|c| *c != OBJ).map(char::len_utf8).sum();
+    if len > 0 {
+        // The caret (focus) stays where typing happens; the characters after it are selected.
+        s.sel = Selection { anchor: Pos { off: f.off + len, ..f.clone() }, focus: f };
+    }
+}
+
 fn insert(s: &mut Session, v: &Value) -> CmdResult {
     let text = p::req_str(v, "text")?;
     let raw = p::bool(v, "raw").unwrap_or(false);
+    typing_options(s, text);
     let t = if raw { None } else { autoformat(s, text) };
     type_text(s, t.as_deref().unwrap_or(text))?;
     let trigger = text.chars().count() == 1 && text.chars().all(|c| c == ' ' || ",.;:!?".contains(c));
@@ -70,11 +99,11 @@ fn insert(s: &mut Session, v: &Value) -> CmdResult {
     let f = s.sel.focus.clone();
     let typed = s.doc.para_at(&f).cloned().map(|p| (p, s.sel.clone()));
     // A list label ("a. ") becomes a list before AutoCorrect could capitalise it.
-    let listed = text == " " && list_autoformat(s)?;
+    let listed = text == " " && s.prefs.autocorrect.enabled && list_autoformat(s)?;
     if !listed {
         super::tools::autocorrect(s)?;
     }
-    if text == " " && !listed {
+    if text == " " && !listed && s.prefs.autocorrect.enabled && s.prefs.autocorrect.dashes {
         dash_autoformat(s)?;
     }
     if let Some((para, sel)) = typed
@@ -90,7 +119,7 @@ fn insert(s: &mut Session, v: &Value) -> CmdResult {
     sel_result(s)
 }
 
-/// "* " / "- " → bullets, "1. " / "a) " → numbering, typed at the start of a paragraph.
+/// "* " / "- " / "> " → bullets, "1. " / "a) " → numbering, typed at the start of a paragraph.
 fn list_autoformat(s: &mut Session) -> Result<bool, CmdError> {
     let f = s.sel.focus.clone();
     let Some(para) = s.doc.para_at(&f) else { return Ok(false) };
@@ -98,8 +127,12 @@ fn list_autoformat(s: &mut Session) -> Result<bool, CmdError> {
         return Ok(false);
     }
     let kind = match para.text.as_str() {
-        "* " | "> " => ListKind::Bullet,
+        "* " => ListKind::Bullet,
         "- " => ListKind::BulletChar('-'),
+        // Arrow bullets (Word draws these from a symbol font; we use the Unicode arrows).
+        "> " => ListKind::BulletChar('\u{27A2}'),
+        "-> " => ListKind::BulletChar('\u{2794}'),
+        "=> " => ListKind::BulletChar('\u{21E8}'),
         "1. " => ListKind::Numbered,
         "1) " => ListKind::NumberedParen,
         "a. " => ListKind::LowerLetterDot,
@@ -109,6 +142,10 @@ fn list_autoformat(s: &mut Session) -> Result<bool, CmdError> {
         "I. " => ListKind::Outline,
         _ => return Ok(false),
     };
+    let ac = &s.prefs.autocorrect;
+    if !(if kind.is_bullet() { ac.bullets } else { ac.numbering }) {
+        return Ok(false);
+    }
     // Bullets join an existing bullet list; typing "1. " always starts numbering again at 1,
     // as in Word.
     let found = if kind.is_bullet() { s.doc.numbering.find_kind(kind) } else { None };
@@ -160,19 +197,27 @@ fn dash_autoformat(s: &mut Session) -> Result<(), CmdError> {
     Ok(())
 }
 
-/// AutoFormat border lines: Enter after "---", "___", "===", "***", "~~~" or "###" turns the
-/// characters into a bottom border on the paragraph above (or this one at the top of a story).
-fn border_line_autoformat(s: &mut Session, at: &Pos) -> Result<bool, CmdError> {
-    let Some(para) = s.doc.para_at(at) else { return Ok(false) };
+/// An AutoFormat that Enter applies to the paragraph just finished.
+enum EnterAutoFormat {
+    /// "---" and friends: a bottom border.
+    Border(Border),
+    /// "+---+-----+": a one-row table; the dash count of each column.
+    Table(Vec<usize>),
+}
+
+/// AutoFormat border lines: Enter after "---", "___", "===", "***", "~~~" or "###".
+fn border_line(s: &Session, at: &Pos) -> Option<Border> {
+    let para = s.doc.para_at(at)?;
     let text = para.text.as_str();
-    let Some(c) = text.chars().next() else { return Ok(false) };
-    if !s.autocorrect_on
+    let c = text.chars().next()?;
+    if !s.prefs.autocorrect.enabled
+        || !s.prefs.autocorrect.border_lines
         || at.off != text.len()
         || text.len() < 3
         || !text.chars().all(|x| x == c)
         || para.props.numbering.is_some_and(|n| n.num != 0)
     {
-        return Ok(false);
+        return None;
     }
     let (style, width) = match c {
         '-' => (BorderStyle::Single, 0.75),
@@ -181,9 +226,39 @@ fn border_line_autoformat(s: &mut Session, at: &Pos) -> Result<bool, CmdError> {
         '*' => (BorderStyle::Dotted, 2.25),
         '~' => (BorderStyle::Wave, 0.75),
         '#' => (BorderStyle::Triple, 0.75),
-        _ => return Ok(false),
+        _ => return None,
     };
-    let line = Border { style, width, color: None, space: 1.0 };
+    Some(Border { style, width, color: None, space: 1.0 })
+}
+
+/// AutoFormat tables: a body paragraph that is exactly "+---+-----+" (plus signs around runs
+/// of hyphens). Returns the hyphen count of each column; more columns than a table can hold
+/// leave the text alone.
+fn table_line(s: &Session, at: &Pos) -> Option<Vec<usize>> {
+    let para = s.doc.para_at(at)?;
+    let text = para.text.as_str();
+    if !s.prefs.autocorrect.enabled
+        || at.story != StoryRef::Body
+        || at.path.0.len() != 1
+        || at.off != text.len()
+        || para.props.numbering.is_some_and(|n| n.num != 0)
+    {
+        return None;
+    }
+    let inner = text.strip_prefix('+')?.strip_suffix('+')?;
+    let mut cols = Vec::new();
+    for run in inner.split('+') {
+        if run.is_empty() || !run.bytes().all(|b| b == b'-') || cols.len() >= wordcraft_doc::table::MAX_COLS {
+            return None;
+        }
+        cols.push(run.len());
+    }
+    Some(cols)
+}
+
+/// Turn the border-line characters into a bottom border on the paragraph above (or this one
+/// at the top of a story).
+fn apply_border_line(s: &mut Session, at: &Pos, line: Border) -> Result<(), CmdError> {
     let set_bottom = |p: &mut wordcraft_doc::Paragraph| {
         let mut b = p.props.borders.unwrap_or_default();
         b.bottom = Some(line);
@@ -192,8 +267,8 @@ fn border_line_autoformat(s: &mut Session, at: &Pos) -> Result<bool, CmdError> {
     };
     let i = at.path.last();
     let prev = if i > 0 { Some(at.path.with_last(i - 1)) } else { None };
-    let len = text.len();
     let cur = s.doc.para_mut(at.story, &at.path)?;
+    let len = cur.len();
     cur.delete(0, len)?;
     let start = Pos { off: 0, ..at.clone() };
     match prev.filter(|q| matches!(s.doc.block(at.story, q), Some(Block::Para(_)))) {
@@ -211,8 +286,34 @@ fn border_line_autoformat(s: &mut Session, at: &Pos) -> Result<bool, CmdError> {
             s.sel = Selection::caret(new);
         }
     }
-    s.goal_x = None;
-    Ok(true)
+    Ok(())
+}
+
+/// Replace the "+---+" characters with a one-row table across the text width, each column as
+/// wide as its share of the hyphens; the emptied paragraph stays after the table and the caret
+/// goes into the first cell.
+fn apply_table_line(s: &mut Session, at: &Pos, cols: &[usize]) -> Result<(), CmdError> {
+    let total = cols.iter().sum::<usize>().max(1) as f32;
+    let block = at.path.0.first().copied().unwrap_or(0) as usize;
+    let width = s.doc.sections().get(s.doc.section_index_of(block)).map(|(_, sp)| sp.text_width()).unwrap_or(468.0).max(36.0);
+    let mut t = Table::new(1, cols.len(), width);
+    for (i, d) in cols.iter().enumerate() {
+        let w = (width * *d as f32 / total).max(6.0);
+        if let Some(g) = t.grid.get_mut(i) {
+            *g = w;
+        }
+        if let Some(c) = t.rows.get_mut(0).and_then(|r| r.cells.get_mut(i)) {
+            c.props.width = Some(w);
+        }
+    }
+    let p = s.doc.para_mut(at.story, &at.path)?;
+    let len = p.len();
+    p.delete(0, len)?;
+    s.doc.insert_block(at.story, &at.path, Block::Table(t))?;
+    let mut first = at.path.0.clone();
+    first.extend([0, 0, 0]);
+    s.sel = Selection::caret(Pos { story: at.story, path: Path(first), off: 0 });
+    Ok(())
 }
 
 /// Toggle Unicode Character (Alt+X): the hex code before the caret (up to six digits, `U+`
@@ -285,8 +386,27 @@ fn ins_char(s: &mut Session, c: char) -> CmdResult {
 }
 
 fn new_paragraph(s: &mut Session, _: &Value) -> CmdResult {
+    // Enter in a one-line plain text control (or a check box or list) does nothing, as in Word.
+    if super::controls::refuses_paragraph(s) {
+        return sel_result(s);
+    }
+    super::controls::prepare_edit(s)?;
     let mut at = delete_selection(s)?;
-    if border_line_autoformat(s, &at)? {
+    let auto = border_line(s, &at).map(EnterAutoFormat::Border).or_else(|| table_line(s, &at).map(EnterAutoFormat::Table));
+    if let Some(auto) = auto {
+        // Word: Undo right after reverts only the AutoFormat, so the typed characters come back
+        // and the Enter stays. Record that plain Enter as its own undo step.
+        let (doc, sel) = (s.doc.clone(), s.sel.clone());
+        let new = split_para(s, &at)?;
+        s.sel = Selection::caret(new);
+        let plain_doc = std::mem::replace(&mut s.doc, doc);
+        let plain_sel = std::mem::replace(&mut s.sel, sel);
+        match auto {
+            EnterAutoFormat::Border(line) => apply_border_line(s, &at, line)?,
+            EnterAutoFormat::Table(cols) => apply_table_line(s, &at, &cols)?,
+        }
+        s.goal_x = None;
+        s.push_undo("AutoFormat", plain_doc, plain_sel);
         return sel_result(s);
     }
     // Enter finishes a word like a space does ("teh" → "the", sentence capitals, links).
@@ -366,7 +486,13 @@ fn back_tab(s: &mut Session, _: &Value) -> CmdResult {
     super::para::outdent(s, &Value::Null)
 }
 
-fn backspace(s: &mut Session, _: &Value) -> CmdResult {
+fn backspace(s: &mut Session, v: &Value) -> CmdResult {
+    let r = backspace_inner(s, v)?;
+    super::controls::restore_placeholder(s)?;
+    Ok(r)
+}
+
+fn backspace_inner(s: &mut Session, _: &Value) -> CmdResult {
     s.goal_x = None;
     s.pending = None;
     if !s.sel.is_collapsed() {
@@ -376,7 +502,7 @@ fn backspace(s: &mut Session, _: &Value) -> CmdResult {
     let f = s.sel.focus.clone();
     let Some(para) = s.doc.para_at(&f) else { return sel_result(s) };
     if f.off > 0 {
-        let a = Pos { off: para.prev_boundary(f.off), ..f.clone() };
+        let a = Pos { off: para.backspace_from(f.off), ..f.clone() };
         s.sel = Selection { anchor: a, focus: f };
         delete_selection(s)?;
         return sel_result(s);
@@ -394,9 +520,10 @@ fn backspace(s: &mut Session, _: &Value) -> CmdResult {
         super::leave_list(s.doc.para_mut(f.story, &f.path)?);
         return sel_result(s);
     }
-    if para.props.indent_first.is_some_and(|x| x > 0.0) {
+    if para.props.indent_first.is_some_and(|x| x > 0.0) || para.props.indent_first_chars.is_some_and(|x| x > 0.0) {
         let p = s.doc.para_mut(f.story, &f.path)?;
         p.props.indent_first = Some(0.0);
+        p.props.cancel_char_indents(false, false, true);
         p.touch();
         return sel_result(s);
     }
@@ -435,7 +562,13 @@ fn backspace(s: &mut Session, _: &Value) -> CmdResult {
     sel_result(s)
 }
 
-fn delete(s: &mut Session, _: &Value) -> CmdResult {
+fn delete(s: &mut Session, v: &Value) -> CmdResult {
+    let r = delete_inner(s, v)?;
+    super::controls::restore_placeholder(s)?;
+    Ok(r)
+}
+
+fn delete_inner(s: &mut Session, _: &Value) -> CmdResult {
     s.goal_x = None;
     s.pending = None;
     if !s.sel.is_collapsed() {
@@ -494,6 +627,7 @@ fn delete_word_back(s: &mut Session, v: &Value) -> CmdResult {
     let a = Pos { off: para.word_start(f.off), ..f.clone() };
     s.sel = Selection { anchor: a, focus: f };
     delete_selection(s)?;
+    super::controls::restore_placeholder(s)?;
     sel_result(s)
 }
 
@@ -509,5 +643,6 @@ fn delete_word_fwd(s: &mut Session, v: &Value) -> CmdResult {
     let b = Pos { off: para.word_end(f.off), ..f.clone() };
     s.sel = Selection { anchor: f, focus: b };
     delete_selection(s)?;
+    super::controls::restore_placeholder(s)?;
     sel_result(s)
 }
diff --git a/crates/engine/src/cmd/tools.rs b/crates/engine/src/cmd/tools.rs
index d7d445441c..3e137f86ea 100644
--- a/crates/engine/src/cmd/tools.rs
+++ b/crates/engine/src/cmd/tools.rs
@@ -1,14 +1,20 @@
 //! Tools and the long tail: Repeat, macros, AutoCorrect, Compare, accessibility checker,
 //! document inspector, restrict editing, versions, templates, Quick Parts, and more.
 
+use serde::{Deserialize, Serialize};
 use serde_json::{Value, json};
+use std::sync::Arc;
 use wordcraft_doc::para::InlineObject;
 use wordcraft_doc::props::{CharProps, NumRef};
+
 use wordcraft_doc::{Block, Document, Paragraph, Pos, RevisionKind, StoryRef, para_block};
 
 use super::{delete_selection, sel_result};
 use crate::{CmdError, CmdResult, CommandSpec, Selection, Session, p};
 
+/// Smileys replaced even when typed straight after a word ("ok:)"), as Word does.
+const SMILEYS: &[&str] = &[":-)", ":-(", ":)", ":(", ":|"];
+
 /// Built-in AutoCorrect replacements (our own list of common typos and symbols).
 pub const AUTOCORRECT: &[(&str, &str)] = &[
     ("teh", "the"),
@@ -45,11 +51,249 @@ pub const AUTOCORRECT: &[(&str, &str)] = &[
     ("<-", "←"),
     ("=>", "⇒"),
     (":)", "☺"),
+    (":-)", "☺"),
+    (":(", "☹"),
+    (":-(", "☹"),
+    (":|", "\u{1F610}"),
     ("1/2", "½"),
     ("1/4", "¼"),
     ("3/4", "¾"),
 ];
 
+/// Compare and Combine take the same settings.
+const COMPARE_PARAMS: &str = r#"{"path"?: string (revised document), "text"?: string (revised text), "original"?: string (original document; default: this one), "author"?: string (label changes with), "caseChanges"?: bool, "whiteSpace"?: bool, "formatting"?: bool (default true: differences count), "level"?: "word|character", "showIn"?: "original|revised|new" (revised/new: an untitled document), "moves"|"comments"|"tables"|"headersFooters"|"footnotes"|"textBoxes"|"fields"?: bool (accepted; not honoured yet except tables, always compared)}"#;
+
+/// AutoCorrect Options (Word keeps them per user; the front end saves them with its preferences).
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct AutoCorrectPrefs {
+    /// All of AutoCorrect and AutoFormat As You Type.
+    pub enabled: bool,
+    /// Replace text as you type (the replacement list).
+    pub replace_text: bool,
+    /// Capitalize the first letter of sentences.
+    pub cap_sentences: bool,
+    /// Capitalize the first letter of table cells.
+    pub cap_cells: bool,
+    /// Capitalize names of days.
+    pub cap_days: bool,
+    /// AutoFormat As You Type: "straight quotes" with “smart quotes”.
+    pub smart_quotes: bool,
+    /// Fractions (1/2) with fraction characters (½).
+    pub fractions: bool,
+    /// Ordinals (1st) with superscript.
+    pub ordinals: bool,
+    /// Hyphens (--) with dashes.
+    pub dashes: bool,
+    /// Internet addresses with hyperlinks.
+    pub links: bool,
+    /// Automatic bulleted lists.
+    pub bullets: bool,
+    /// Automatic numbered lists.
+    pub numbering: bool,
+    /// Border lines.
+    pub border_lines: bool,
+    /// The user's entries: added, or replacing a built-in one.
+    pub entries: Vec<(String, String)>,
+    /// Built-in entries the user deleted.
+    pub removed: Vec<String>,
+    /// Abbreviations the user added after which a sentence doesn't end ("approx.").
+    pub exceptions: Vec<String>,
+    /// Built-in abbreviations the user deleted from the exceptions.
+    pub exceptions_removed: Vec<String>,
+}
+
+impl Default for AutoCorrectPrefs {
+    fn default() -> Self {
+        AutoCorrectPrefs {
+            enabled: true,
+            replace_text: true,
+            cap_sentences: true,
+            cap_cells: true,
+            cap_days: true,
+            smart_quotes: true,
+            fractions: true,
+            ordinals: true,
+            dashes: true,
+            links: true,
+            bullets: true,
+            numbering: true,
+            border_lines: true,
+            entries: Vec::new(),
+            removed: Vec::new(),
+            exceptions: Vec::new(),
+            exceptions_removed: Vec::new(),
+        }
+    }
+}
+
+/// Longest AutoCorrect "replace" text, in characters.
+const MAX_FROM: usize = 255;
+/// Longest "with" text, in characters.
+const MAX_TO: usize = 2000;
+/// Most entries (and exceptions) kept.
+const MAX_ENTRIES: usize = 10_000;
+
+/// Built-in fractions: AutoFormat's (Fractions), not the replacement list's.
+const FRACTIONS: [&str; 3] = ["1/2", "1/4", "3/4"];
+
+impl AutoCorrectPrefs {
+    /// Drop what a damaged or hostile saved value could hold: empty or overlong entries,
+    /// duplicates, too many of them.
+    pub fn cleaned(mut self) -> Self {
+        let ok = |t: &str, max: usize| !t.trim().is_empty() && t.chars().count() <= max && !t.contains(['\n', '\r']);
+        let mut seen = std::collections::HashSet::new();
+        self.entries.retain(|(a, b)| ok(a, MAX_FROM) && b.chars().count() <= MAX_TO && !b.contains(['\n', '\r']) && seen.insert(a.clone()));
+        self.entries.truncate(MAX_ENTRIES);
+        for list in [&mut self.removed, &mut self.exceptions, &mut self.exceptions_removed] {
+            let mut seen = std::collections::HashSet::new();
+            list.retain(|a| ok(a, MAX_FROM) && seen.insert(a.clone()));
+            list.truncate(MAX_ENTRIES);
+        }
+        self
+    }
+
+    /// The replacement for `word`, if any: the user's entry, else a built-in one not deleted.
+    /// Built-in lowercase entries also match a capitalised word ("Teh" → "The").
+    pub fn replacement(&self, word: &str) -> Option<String> {
+        if let Some((_, b)) = self.entries.iter().find(|(a, _)| a == word) {
+            return Some(b.clone());
+        }
+        AUTOCORRECT
+            .iter()
+            .filter(|(a, _)| !self.removed.iter().any(|r| r == a) && !self.entries.iter().any(|(e, _)| e == a))
+            .filter(|(a, _)| self.fractions || !FRACTIONS.contains(a))
+            .find(|(a, _)| {
+                *a == word
+                    || (a.chars().all(|c| c.is_lowercase()) && word.to_lowercase() == *a && word.chars().next().is_some_and(char::is_uppercase))
+            })
+            .map(|(a, b)| {
+                if *a != word && b.chars().next().is_some_and(char::is_lowercase) {
+                    let mut c = b.chars();
+                    c.next().map(|x| x.to_uppercase().chain(c).collect::<String>()).unwrap_or_default()
+                } else {
+                    b.to_string()
+                }
+            })
+    }
+
+    /// The replacement list as the dialog shows it, sorted: `(from, to, built in)`.
+    pub fn list(&self) -> Vec<(String, String, bool)> {
+        let mut v: Vec<(String, String, bool)> = AUTOCORRECT
+            .iter()
+            .filter(|(a, _)| !self.removed.iter().any(|r| r == a) && !self.entries.iter().any(|(e, _)| e == a))
+            .map(|(a, b)| (a.to_string(), b.to_string(), true))
+            .chain(self.entries.iter().map(|(a, b)| (a.clone(), b.clone(), false)))
+            .collect();
+        v.sort_by(|x, y| x.0.to_lowercase().cmp(&y.0.to_lowercase()).then(x.0.cmp(&y.0)));
+        v
+    }
+
+    /// Abbreviations after which a sentence doesn't end, lowercase.
+    pub fn exception_list(&self) -> Vec<String> {
+        let mut v: Vec<String> = NOT_SENTENCE_END
+            .iter()
+            .filter(|a| !self.exceptions_removed.iter().any(|r| r.eq_ignore_ascii_case(a)))
+            .map(|a| a.to_string())
+            .chain(self.exceptions.iter().map(|a| a.to_lowercase()))
+            .collect();
+        v.sort();
+        v.dedup();
+        v
+    }
+}
+
+/// Saved AutoCorrect options: anything that doesn't read as them reads as the defaults (a
+/// damaged `ui.json` never loses the other preferences).
+pub fn lenient_autocorrect<'de, D: serde::Deserializer<'de>>(d: D) -> Result<AutoCorrectPrefs, D::Error> {
+    let v = Value::deserialize(d)?;
+    Ok(serde_json::from_value::<AutoCorrectPrefs>(v).map(AutoCorrectPrefs::cleaned).unwrap_or_default())
+}
+
+/// `tools.autocorrect`: change AutoCorrect Options and report them.
+fn autocorrect_options(s: &mut Session, v: &Value) -> CmdResult {
+    let ac = &mut s.prefs.autocorrect;
+    for (k, f) in [
+        ("enabled", &mut ac.enabled as &mut bool),
+        ("replaceText", &mut ac.replace_text),
+        ("capSentences", &mut ac.cap_sentences),
+        ("capCells", &mut ac.cap_cells),
+        ("capDays", &mut ac.cap_days),
+        ("smartQuotes", &mut ac.smart_quotes),
+        ("fractions", &mut ac.fractions),
+        ("ordinals", &mut ac.ordinals),
+        ("dashes", &mut ac.dashes),
+        ("links", &mut ac.links),
+        ("bullets", &mut ac.bullets),
+        ("numbering", &mut ac.numbering),
+        ("borderLines", &mut ac.border_lines),
+    ] {
+        if let Some(b) = p::bool(v, k) {
+            *f = b;
+        }
+    }
+    let bad = |t: &str, max: usize| t.trim().is_empty() || t.chars().count() > max || t.contains(['\n', '\r']);
+    if let Some(add) = v.get("add") {
+        let (Some(f), Some(t)) = (add.get("from").and_then(Value::as_str), add.get("to").and_then(Value::as_str)) else {
+            return Err(CmdError::Params("`add` is {\"from\": string, \"to\": string}".into()));
+        };
+        if bad(f, MAX_FROM) || t.chars().count() > MAX_TO || t.contains(['\n', '\r']) {
+            return Err(CmdError::Params(format!("an entry replaces 1–{MAX_FROM} characters (one line) with at most {MAX_TO}")));
+        }
+        ac.entries.retain(|(a, _)| a != f);
+        if ac.entries.len() >= MAX_ENTRIES {
+            return Err(CmdError::Params("too many AutoCorrect entries".into()));
+        }
+        ac.entries.push((f.to_string(), t.to_string()));
+        ac.removed.retain(|r| r != f);
+    }
+    if let Some(f) = p::str(v, "delete") {
+        let n = ac.entries.len();
+        ac.entries.retain(|(a, _)| a != f);
+        if AUTOCORRECT.iter().any(|(a, _)| *a == f) && !ac.removed.iter().any(|r| r == f) {
+            ac.removed.push(f.to_string());
+        } else if n == ac.entries.len() {
+            return Err(CmdError::Params(format!("no AutoCorrect entry {f:?}")));
+        }
+    }
+    if let Some(e) = p::str(v, "addException") {
+        let e = e.trim().to_lowercase();
+        if bad(&e, MAX_FROM) || e.contains(char::is_whitespace) {
+            return Err(CmdError::Params("an exception is one abbreviation, like \"approx.\"".into()));
+        }
+        ac.exceptions_removed.retain(|r| *r != e);
+        if !NOT_SENTENCE_END.contains(&e.as_str()) && !ac.exceptions.contains(&e) && ac.exceptions.len() < MAX_ENTRIES {
+            ac.exceptions.push(e);
+        }
+    }
+    if let Some(e) = p::str(v, "deleteException") {
+        let e = e.trim().to_lowercase();
+        ac.exceptions.retain(|r| *r != e);
+        if NOT_SENTENCE_END.contains(&e.as_str()) && !ac.exceptions_removed.contains(&e) {
+            ac.exceptions_removed.push(e);
+        }
+    }
+    let ac = &s.prefs.autocorrect;
+    Ok(json!({
+        "enabled": ac.enabled,
+        "replaceText": ac.replace_text,
+        "capSentences": ac.cap_sentences,
+        "capCells": ac.cap_cells,
+        "capDays": ac.cap_days,
+        "smartQuotes": ac.smart_quotes,
+        "fractions": ac.fractions,
+        "ordinals": ac.ordinals,
+        "dashes": ac.dashes,
+        "links": ac.links,
+        "bullets": ac.bullets,
+        "numbering": ac.numbering,
+        "borderLines": ac.border_lines,
+        "entries": ac.list().into_iter().map(|(a, b, builtin)| json!({"from": a, "to": b, "builtIn": builtin})).collect::<Vec<_>>(),
+        "user": ac.entries,
+        "exceptions": ac.exception_list(),
+    }))
+}
+
 pub fn specs() -> Vec<CommandSpec> {
     vec![
         CommandSpec::new("edit.repeat", "Repeat", "Quick Access Toolbar", |s, _| {
@@ -75,20 +319,11 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("tools.macros", "Macros", "View › Macros", macros)
             .params(r#"{"run"?: name, "define"?: {"name": string, "steps": [{"command", "params"}]}, "delete"?: name}"#)
             .pure(),
-        CommandSpec::new("tools.autocorrect", "AutoCorrect Options", "File › Options › Proofing", |s, v| {
-            if let Some(b) = p::bool(v, "enabled") {
-                s.autocorrect_on = b;
-            }
-            if let (Some(f), Some(t)) =
-                (v.get("add").and_then(|a| a.get("from")).and_then(Value::as_str), v.get("add").and_then(|a| a.get("to")).and_then(Value::as_str))
-            {
-                s.autocorrect_user.retain(|(a, _)| a != f);
-                s.autocorrect_user.push((f.to_string(), t.to_string()));
-            }
-            Ok(json!({"enabled": s.autocorrect_on, "entries": AUTOCORRECT.len() + s.autocorrect_user.len(), "user": s.autocorrect_user}))
-        })
-        .params(r#"{"enabled"?: bool, "add"?: {"from": string, "to": string}}"#)
-        .pure(),
+        CommandSpec::new("tools.autocorrect", "AutoCorrect Options", "File › Options › Proofing", autocorrect_options)
+            .params(
+                r#"{"enabled"?: bool (all of AutoCorrect), "replaceText"|"capSentences"|"capCells"|"capDays"|"smartQuotes"|"fractions"|"ordinals"|"dashes"|"links"|"bullets"|"numbering"|"borderLines"?: bool, "add"?: {"from": string, "to": string} (adds or replaces an entry), "delete"?: string (an entry's "from", built in or added), "addException"?: string, "deleteException"?: string} → options, entries and exceptions"#,
+            )
+            .pure(),
         CommandSpec::new("tools.customizeKeyboard", "Customize Keyboard", "File › Options", customize_keyboard)
             .params(
                 r#"{"command"?: id (its keys), "key"?: "Mod+Shift+K" (the command it runs), "assign"?: {"command": id, "key": string}, "remove"?: {"command": id, "key": string}, "reset"?: true (built-in keys only)} → {custom: {assigned: {key: id}, removed: [key]}, …}; no params opens the dialog"#,
@@ -99,20 +334,11 @@ pub fn specs() -> Vec<CommandSpec> {
                 r#"{"hide"?: tab, "show"?: tab, "newTab"?: {"name"?, "after"?: tab}, "newGroup"?: {"tab", "name"?}, "add"?: {"tab", "group", "command", "after"?: id}, "remove"?: {"tab", "group"?, "command"?}, "rename"?: {"tab", "group"?, "to"}, "move"?: {"tab", "group"?, "command"?, "by": int}, "qatAdd"?: id, "qatRemove"?: id, "qatMove"?: {"command", "by": int}, "reset"?: true | "ribbon" | "qat", "layout"?: object} → {tabs: [{name, custom?, hidden?, groups?: [{name, commands}]}], qat: [id]}; only custom tabs and groups can be renamed or removed (built-in tabs can be hidden and moved); no params opens the dialog"#,
             )
             .pure(),
-        CommandSpec::new("review.compare", "Compare", "Review › Compare", compare).params(r#"{"path"?: string, "text"?: string (revised version)}"#),
-        CommandSpec::new("review.combine", "Combine", "Review › Compare", compare).params(r#"{"path"?: string}"#),
+        CommandSpec::new("review.compare", "Compare", "Review › Compare", compare).params(COMPARE_PARAMS),
+        CommandSpec::new("review.combine", "Combine", "Review › Compare", compare).params(COMPARE_PARAMS),
         CommandSpec::new("file.accessibility", "Check Accessibility", "Review › Accessibility", accessibility).pure(),
         CommandSpec::new("file.inspect", "Inspect Document", "File › Info", inspect_doc)
             .params(r#"{"remove"?: ["comments", "revisions", "properties", "hidden", "headers"]}"#),
-        CommandSpec::new("review.restrict", "Restrict Editing", "Review › Protect", |s, v| {
-            let mode = p::str(v, "mode").unwrap_or("readOnly").to_string();
-            s.doc.settings.protection = if mode == "none" { None } else { Some(mode.clone()) };
-            if mode == "trackedChanges" {
-                s.doc.settings.track_changes = true;
-            }
-            Ok(json!({"protection": s.doc.settings.protection}))
-        })
-        .params(r#"{"mode": "none|readOnly|comments|trackedChanges|forms"}"#),
         CommandSpec::new("file.protect", "Protect Document", "File › Info", |s, v| {
             let mode = p::str(v, "mode").unwrap_or("readOnly");
             s.run("review.restrict", &json!({"mode": mode}))
@@ -350,8 +576,9 @@ pub fn specs() -> Vec<CommandSpec> {
             })
         })
         .params(r#"{"format": "decimal|upperRoman|lowerLetter…", "text"?: "%1.", "start"?: n}"#),
-        CommandSpec::new("review.language", "Language", "Review › Language", set_language)
-            .params(r#"{"lang"?: "en-US|en-GB|pl-PL|fr-FR|…" (BCP 47; default en-US), "noProof"?: bool, "default"?: bool (also the document's default language)}"#),
+        CommandSpec::new("review.language", "Language", "Review › Language", language).params(
+            r#"{"lang"?: "en-US|en-GB|pl-PL|fr-FR|…" (BCP 47; default en-US), "noProof"?: bool, "detect"?: bool (detect language automatically, a preference), "default"?: bool (also the document's default language)}"#,
+        ),
         CommandSpec::new("review.showMarkup", "Show Markup", "Review › Tracking", |s, v| {
             s.view.show_markup = p::bool(v, "value").unwrap_or(!s.view.show_markup);
             s.relayout();
@@ -401,6 +628,49 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
+/// Set Proofing Language: the selection's language and "do not check spelling or grammar",
+/// or (`default`) the document's default language; `detect` is the per-user preference.
+/// Nothing at all sets US English, as before.
+fn language(s: &mut Session, v: &Value) -> CmdResult {
+    let lang = match p::str(v, "lang") {
+        Some(t) => Some(
+            wordcraft_proof::lang::normalize_tag(t)
+                .ok_or_else(|| CmdError::Params(format!("`lang` must be a language tag such as pl-PL or en-US, not {t:?}")))?,
+        ),
+        None => None,
+    };
+    let no_proof = p::bool(v, "noProof");
+    let detect = p::bool(v, "detect");
+    if let Some(d) = detect {
+        s.prefs.detect_language = d;
+    }
+    if p::bool(v, "default") == Some(true) {
+        let l = lang.clone().ok_or_else(|| CmdError::Params("`default` needs `lang`".into()))?;
+        s.doc.styles.default_chr.lang = Some(l.clone());
+        // A Normal style that names its own language follows the new default.
+        if let Some(n) = s.doc.styles.styles.iter_mut().find(|x| x.id == "Normal")
+            && n.chr.lang.is_some()
+        {
+            n.chr.lang = Some(l);
+        }
+    }
+    let lang = match (lang, no_proof, detect) {
+        (None, None, None) => Some("en-US".to_string()),
+        (l, ..) => l,
+    };
+    if lang.is_none() && no_proof.is_none() {
+        return Ok(json!({"detect": s.prefs.detect_language}));
+    }
+    super::format::apply(s, &|c| {
+        if let Some(l) = &lang {
+            c.lang = Some(l.clone());
+        }
+        if let Some(np) = no_proof {
+            c.no_proof = Some(np);
+        }
+    })
+}
+
 fn macros(s: &mut Session, v: &Value) -> CmdResult {
     if let Some(d) = v.get("define") {
         let name = d.get("name").and_then(Value::as_str).unwrap_or("Macro").to_string();
@@ -440,9 +710,10 @@ pub fn autocorrect(s: &mut Session) -> Result<(), CmdError> {
 /// AutoCorrect the word ending at the caret; `on_enter` means Enter finished it (no trigger
 /// character was typed).
 pub fn autocorrect_word(s: &mut Session, on_enter: bool) -> Result<(), CmdError> {
-    if !s.autocorrect_on {
+    if !s.prefs.autocorrect.enabled {
         return Ok(());
     }
+    let ac = s.prefs.autocorrect.clone();
     let f = s.sel.focus.clone();
     let Some(text) = s.doc.para_at(&f).map(|p| p.text.clone()) else { return Ok(()) };
     let Some(before) = text.get(..f.off) else { return Ok(()) };
@@ -457,24 +728,16 @@ pub fn autocorrect_word(s: &mut Session, on_enter: bool) -> Result<(), CmdError>
     if word.is_empty() {
         return Ok(());
     }
-    let user = s.autocorrect_user.iter().find(|(a, _)| *a == word).map(|(_, b)| b.clone());
-    let builtin = AUTOCORRECT
-        .iter()
-        .find(|(a, _)| {
-            *a == word || (a.chars().all(|c| c.is_lowercase()) && word.to_lowercase() == *a && word.chars().next().is_some_and(char::is_uppercase))
-        })
-        .map(|(a, b)| {
-            if *a != word && b.chars().next().is_some_and(char::is_lowercase) {
-                let mut c = b.chars();
-                c.next().map(|x| x.to_uppercase().chain(c).collect::<String>()).unwrap_or_default()
-            } else {
-                b.to_string()
-            }
-        });
     // A whole-word replacement, else "wait..." → "wait…".
-    let (from, rep) = match user.or(builtin) {
+    let found = if ac.replace_text { ac.replacement(&word) } else { None };
+    let (from, rep) = match found {
         Some(r) => (start, Some(r)),
-        None if word.len() > 3 && word.ends_with("...") => (start + word.len() - 3, Some("…".to_string())),
+        None if ac.replace_text && word.len() > 3 && word.ends_with("...") => (start + word.len() - 3, Some("…".to_string())),
+        None if ac.replace_text => match SMILEYS.iter().find(|m| word.len() > m.len() && word.ends_with(**m)) {
+            // "ok:)" → "ok☺": only the smiley at the end of the word is replaced.
+            Some(m) => (start + word.len() - m.len(), AUTOCORRECT.iter().find(|(a, _)| a == m).map(|(_, b)| b.to_string())),
+            None => (start, None),
+        },
         None => (start, None),
     };
     let mut caret = f.off;
@@ -491,13 +754,13 @@ pub fn autocorrect_word(s: &mut Session, on_enter: bool) -> Result<(), CmdError>
     let Some(word) = s.doc.para_at(&f).and_then(|p| p.text.get(start..end)).map(str::to_string) else { return Ok(()) };
     let at = |off: usize| Pos { off, ..f.clone() };
     // 1st, 22nd, 103rd → superscript suffix.
-    if let Some(n) = ordinal_suffix(&word) {
+    if let Some(n) = ordinal_suffix(&word).filter(|_| ac.ordinals) {
         s.doc.format_range(&at(end - n), &at(end), &|c| c.vert_align = Some(wordcraft_doc::props::VertAlign::Superscript))?;
         return Ok(());
     }
     // Web addresses become links (trailing punctuation stays outside).
     let lower = word.to_ascii_lowercase();
-    if (lower.starts_with("http://") || lower.starts_with("https://") || lower.starts_with("www.")) && word.len() > 8 {
+    if ac.links && (lower.starts_with("http://") || lower.starts_with("https://") || lower.starts_with("www.")) && word.len() > 8 {
         let url = word.trim_end_matches(|c: char| ".,;:!?)]\"'”’".contains(c));
         let href = if lower.starts_with("www.") { format!("http://{url}") } else { url.to_string() };
         let url_end = start + url.len();
@@ -512,7 +775,22 @@ pub fn autocorrect_word(s: &mut Session, on_enter: bool) -> Result<(), CmdError>
         s.pending = Some(after);
         return Ok(());
     }
-    if starts_sentence(text.get(..start).unwrap_or("")) && should_capitalize(&word, if on_enter { '\n' } else { last }) {
+    let before_word = text.get(..start).unwrap_or("");
+    // The first word in a table cell follows its own option; other sentences the sentence one.
+    let sentence_on = if before_word.trim().is_empty() && f.path.cell().is_some() { ac.cap_cells } else { ac.cap_sentences };
+    let exceptions = ac.exception_list();
+    // A replacement of several words ("brb" → "be right back") is capitalised by its first.
+    let first = word.split_whitespace().next().unwrap_or("");
+    let next = if first.len() < word.len() {
+        ' '
+    } else if on_enter {
+        '\n'
+    } else {
+        last
+    };
+    let sentence = sentence_on && starts_sentence(before_word, &exceptions) && should_capitalize(first, next);
+    let day = ac.cap_days && DAYS.contains(&first);
+    if sentence || day {
         let para = s.doc.para_mut(f.story, &f.path)?;
         if let Some(c) = word.chars().next() {
             let up: String = c.to_uppercase().collect();
@@ -550,8 +828,12 @@ const NOT_SENTENCE_END: &[&str] = &[
     "ltd.", "co.", "vol.", "a.m.", "p.m.",
 ];
 
+/// Names of days, capitalised as you type (Capitalize names of days).
+const DAYS: [&str; 7] = ["monday", "tuesday", "wednesday", "thursday", "friday", "saturday", "sunday"];
+
 /// Does a word typed after `before` (the paragraph text up to the word) begin a sentence?
-fn starts_sentence(before: &str) -> bool {
+/// `exceptions` are the lowercase abbreviations whose full stop doesn't end one.
+fn starts_sentence(before: &str, exceptions: &[String]) -> bool {
     let t = before.trim_end();
     if t.is_empty() {
         return true;
@@ -567,7 +849,7 @@ fn starts_sentence(before: &str) -> bool {
     let lower = prev.to_lowercase();
     // "J." (an initial) or a known abbreviation.
     let initial = prev.chars().count() == 2 && prev.chars().next().is_some_and(char::is_uppercase);
-    !initial && !NOT_SENTENCE_END.contains(&lower.as_str())
+    !initial && !exceptions.contains(&lower)
 }
 
 /// Only plain lowercase words are capitalised (not "iPhone", "x2", file names or addresses).
@@ -585,8 +867,34 @@ fn should_capitalize(word: &str, next: char) -> bool {
         && !word.trim_end_matches('.').contains('.')
 }
 
-/// Compare the current document (original) with a revised one: the result shows the
-/// differences as tracked insertions and deletions.
+/// What Compare / Combine compares (the More >> settings of Word's dialog).
+struct CompareOptions {
+    /// Differences only in letter case count as changes.
+    case: bool,
+    /// Differences only in white space count as changes.
+    white_space: bool,
+    /// Formatting differences become tracked formatting changes.
+    formatting: bool,
+    /// Changed paragraphs are compared character by character (else word by word).
+    characters: bool,
+}
+
+impl CompareOptions {
+    /// The text a comparison sees: case folded and white space collapsed as the options say.
+    fn key(&self, t: &str) -> String {
+        let t = if self.white_space { t.to_string() } else { t.split_whitespace().collect::<Vec<_>>().join(" ") };
+        if self.case { t } else { t.to_lowercase() }
+    }
+}
+
+/// Changed paragraphs longer than this (in characters) are compared word by word even at
+/// character level, so the comparison table stays small.
+const MAX_CHAR_DIFF: usize = 2000;
+
+/// Compare the current document (original, or `original` from a file) with a revised one: the
+/// result shows the differences as tracked insertions, deletions and formatting changes, labelled
+/// with `author`. Options Word offers that the comparison can't honour yet (moves, comments,
+/// headers and footers, footnotes, text boxes, fields) are accepted and listed in the result.
 fn compare(s: &mut Session, v: &Value) -> CmdResult {
     let revised = if let Some(t) = p::str(v, "text") {
         Document::from_text(t)
@@ -595,63 +903,132 @@ fn compare(s: &mut Session, v: &Value) -> CmdResult {
     } else {
         return Err(CmdError::Params("`path` or `text` of the revised document is required".into()));
     };
-    let old: Vec<Paragraph> = s.doc.body.iter().filter_map(|b| b.as_para().cloned()).collect();
-    let new: Vec<Paragraph> = revised.body.iter().filter_map(|b| b.as_para().cloned()).collect();
-    let author = "Compare".to_string();
+    let show_in = p::str(v, "showIn").unwrap_or("original");
+    if !matches!(show_in, "original" | "revised" | "new") {
+        return Err(CmdError::Params("`showIn` is \"original\", \"revised\" or \"new\"".into()));
+    }
+    if let Some(path) = p::str(v, "original") {
+        let doc = crate::io::open_path(std::path::Path::new(path)).map_err(CmdError::Failed)?;
+        s.doc = doc;
+        s.doc.ensure_nonempty();
+    }
+    let level = p::str(v, "level").unwrap_or("word");
+    let opts = CompareOptions {
+        case: p::bool(v, "caseChanges").unwrap_or(true),
+        white_space: p::bool(v, "whiteSpace").unwrap_or(true),
+        formatting: p::bool(v, "formatting").unwrap_or(true),
+        characters: matches!(level, "character" | "char"),
+    };
+    let not_honoured: Vec<&str> =
+        ["moves", "comments", "headersFooters", "footnotes", "textBoxes", "fields"].into_iter().filter(|k| v.get(*k).is_some()).collect();
+    let author = p::str(v, "author").map(str::trim).filter(|a| !a.is_empty()).map(str::to_string).unwrap_or_else(|| s.author.clone());
     let date = super::now_iso();
+    let old: Vec<Arc<Block>> = s.doc.body.clone();
+    let new: Vec<Arc<Block>> = revised.body.clone();
     s.doc.revisions.push(wordcraft_doc::Revision { kind: RevisionKind::Insert, author: author.clone(), date: date.clone(), move_name: None });
     let ins = (s.doc.revisions.len() - 1) as u32;
-    s.doc.revisions.push(wordcraft_doc::Revision { kind: RevisionKind::Delete, author, date, move_name: None });
+    s.doc.revisions.push(wordcraft_doc::Revision { kind: RevisionKind::Delete, author: author.clone(), date: date.clone(), move_name: None });
     let del = (s.doc.revisions.len() - 1) as u32;
-    let ops = lcs_ops(&old.iter().map(|p| p.plain_text()).collect::<Vec<_>>(), &new.iter().map(|p| p.plain_text()).collect::<Vec<_>>());
-    let mut out: Vec<Paragraph> = Vec::new();
+    let key = |b: &Arc<Block>| match &**b {
+        Block::Para(p) => opts.key(&p.plain_text()),
+        // Tables match as a whole, by their text.
+        Block::Table(_) => format!("\u{0}table\u{0}{}", opts.key(&block_text(b, 0))),
+    };
+    let ops = lcs_ops(&old.iter().map(key).collect::<Vec<_>>(), &new.iter().map(key).collect::<Vec<_>>());
+    let mut out: Vec<Arc<Block>> = Vec::new();
     let (mut i, mut j) = (0usize, 0usize);
     let mut changes = 0usize;
     let mut k = 0;
     while k < ops.len() {
         match ops.get(k) {
             Some(Op::Same) => {
-                if let Some(p) = old.get(i) {
-                    out.push(p.clone());
+                let (a, b) = (old.get(i), new.get(j));
+                // The revised block, with its formatting changes tracked.
+                if let (Some(Block::Para(pa)), Some(Block::Para(pb))) = (a.map(|x| &**x), b.map(|x| &**x)) {
+                    let mut p = pb.clone();
+                    if opts.formatting && pa.text == pb.text {
+                        let before = s.doc.revisions.len();
+                        super::fmt_revisions::compare_formatting(pa, &mut p, &mut s.doc.revisions, &author, &date);
+                        if s.doc.revisions.len() > before || p != *pb {
+                            changes += 1;
+                        }
+                    }
+                    out.push(para_block(p));
+                } else if let Some(x) = b.or(a) {
+                    out.push(x.clone());
                 }
                 i += 1;
                 j += 1;
                 k += 1;
             }
-            Some(Op::Del) if matches!(ops.get(k + 1), Some(Op::Ins)) => {
-                // A changed paragraph: diff its words.
-                let (a, b) = (old.get(i).cloned().unwrap_or_default(), new.get(j).cloned().unwrap_or_default());
-                out.push(word_diff(&a, &b, ins, del));
-                changes += 1;
-                i += 1;
-                j += 1;
-                k += 2;
-            }
-            Some(Op::Del) => {
-                let mut p = old.get(i).cloned().unwrap_or_default();
-                let len = p.len();
-                let _ = p.format(0, len, &|c| c.del = Some(del));
-                out.push(p);
-                changes += 1;
-                i += 1;
-                k += 1;
-            }
-            Some(Op::Ins) => {
-                let mut p = new.get(j).cloned().unwrap_or_default();
-                let len = p.len();
-                let _ = p.format(0, len, &|c| c.ins = Some(ins));
-                out.push(p);
-                changes += 1;
-                j += 1;
-                k += 1;
+            Some(_) => {
+                // A run of deletions and insertions: changed paragraphs pair up and are diffed
+                // word by word (or by character); the rest are deleted or inserted whole.
+                let run = ops.get(k..).unwrap_or_default().iter().take_while(|o| **o != Op::Same).count();
+                let dels = ops.get(k..k + run).unwrap_or_default().iter().filter(|o| **o == Op::Del).count();
+                let inss = run - dels;
+                for x in 0..dels.max(inss) {
+                    let (a, b) = (if x < dels { old.get(i + x) } else { None }, if x < inss { new.get(j + x) } else { None });
+                    match (a.map(|x| &**x), b.map(|x| &**x)) {
+                        (Some(Block::Para(pa)), Some(Block::Para(pb))) => out.push(para_block(word_diff(pa, pb, ins, del, &opts))),
+                        _ => {
+                            if let Some(x) = a {
+                                out.push(Arc::new(mark_block(x, &|c| c.del = Some(del), 0)));
+                            }
+                            if let Some(x) = b {
+                                out.push(Arc::new(mark_block(x, &|c| c.ins = Some(ins), 0)));
+                            }
+                        }
+                    }
+                    changes += 1;
+                }
+                i += dels;
+                j += inss;
+                k += run.max(1);
             }
             None => break,
         }
     }
-    s.doc.body = out.into_iter().map(para_block).collect();
+    s.doc.body = out;
     s.doc.ensure_nonempty();
+    if show_in != "original" || p::str(v, "original").is_some() {
+        // The result is a new, untitled document: saving it never overwrites either file.
+        s.path = None;
+    }
     s.sel = Selection::caret(s.doc.start_of(StoryRef::Body));
-    Ok(json!({"changes": changes}))
+    Ok(json!({"changes": changes, "author": author, "notHonoured": not_honoured}))
+}
+
+/// A block's text (a table's cells in order), for matching blocks.
+fn block_text(b: &Block, depth: usize) -> String {
+    match b {
+        Block::Para(p) => p.plain_text(),
+        Block::Table(t) if depth < 16 => {
+            t.rows.iter().flat_map(|r| r.cells.iter()).flat_map(|c| c.blocks.iter()).map(|x| block_text(x, depth + 1)).collect::<Vec<_>>().join("\t")
+        }
+        Block::Table(_) => String::new(),
+    }
+}
+
+/// A copy of the block with every run (in tables, every cell's) changed by `f`.
+fn mark_block(b: &Block, f: &dyn Fn(&mut CharProps), depth: usize) -> Block {
+    match b {
+        Block::Para(p) => {
+            let mut p = p.clone();
+            let len = p.len();
+            let _ = p.format(0, len, f);
+            Block::Para(p)
+        }
+        Block::Table(t) => {
+            let mut t = t.clone();
+            if depth < 16 {
+                for c in t.rows.iter_mut().flat_map(|r| r.cells.iter_mut()) {
+                    c.blocks = c.blocks.iter().map(|x| Arc::new(mark_block(x, f, depth + 1))).collect();
+                }
+            }
+            Block::Table(t)
+        }
+    }
 }
 
 #[derive(Clone, Copy, Debug, PartialEq)]
@@ -661,9 +1038,19 @@ enum Op {
     Ins,
 }
 
-/// LCS edit script between two sequences (bounded size).
+/// Longest sequence the comparison table is built for; the rest of a longer sequence is
+/// compared as deleted and inserted, never dropped.
+const MAX_LCS: usize = 4000;
+
+/// LCS edit script between two sequences: the common start and end are matched first, then the
+/// middle (bounded size).
 fn lcs_ops<T: PartialEq>(a: &[T], b: &[T]) -> Vec<Op> {
-    let (n, m) = (a.len().min(4000), b.len().min(4000));
+    let pre = a.iter().zip(b).take_while(|(x, y)| x == y).count();
+    let (ra, rb) = (a.get(pre..).unwrap_or_default(), b.get(pre..).unwrap_or_default());
+    let suf = ra.iter().rev().zip(rb.iter().rev()).take_while(|(x, y)| x == y).count();
+    let (a, b) = (ra.get(..ra.len() - suf).unwrap_or_default(), rb.get(..rb.len() - suf).unwrap_or_default());
+    let mut ops = vec![Op::Same; pre];
+    let (n, m) = (a.len().min(MAX_LCS), b.len().min(MAX_LCS));
     let mut t = vec![vec![0u32; m + 1]; n + 1];
     for i in (0..n).rev() {
         for j in (0..m).rev() {
@@ -678,7 +1065,6 @@ fn lcs_ops<T: PartialEq>(a: &[T], b: &[T]) -> Vec<Op> {
         }
     }
     let (mut i, mut j) = (0, 0);
-    let mut ops = Vec::new();
     while i < n && j < m {
         if a.get(i) == b.get(j) {
             ops.push(Op::Same);
@@ -692,12 +1078,17 @@ fn lcs_ops<T: PartialEq>(a: &[T], b: &[T]) -> Vec<Op> {
             j += 1;
         }
     }
-    ops.extend(std::iter::repeat_n(Op::Del, n - i));
-    ops.extend(std::iter::repeat_n(Op::Ins, m - j));
+    ops.extend(std::iter::repeat_n(Op::Del, a.len() - i));
+    ops.extend(std::iter::repeat_n(Op::Ins, b.len() - j));
+    ops.extend(std::iter::repeat_n(Op::Same, suf));
     ops
 }
 
-fn tokens(s: &str) -> Vec<String> {
+/// Words with the spaces after them ("The ", "cat "), or single characters.
+fn tokens(s: &str, characters: bool) -> Vec<String> {
+    if characters {
+        return s.chars().map(String::from).collect();
+    }
     let mut v = Vec::new();
     let mut cur = String::new();
     for c in s.chars() {
@@ -712,9 +1103,11 @@ fn tokens(s: &str) -> Vec<String> {
     v
 }
 
-fn word_diff(a: &Paragraph, b: &Paragraph, ins: u32, del: u32) -> Paragraph {
-    let (ta, tb) = (tokens(&a.plain_text()), tokens(&b.plain_text()));
-    let ops = lcs_ops(&ta, &tb);
+fn word_diff(a: &Paragraph, b: &Paragraph, ins: u32, del: u32, opts: &CompareOptions) -> Paragraph {
+    let (at, bt) = (a.plain_text(), b.plain_text());
+    let chars = opts.characters && at.chars().count().max(bt.chars().count()) <= MAX_CHAR_DIFF;
+    let (ta, tb) = (tokens(&at, chars), tokens(&bt, chars));
+    let ops = lcs_ops(&ta.iter().map(|t| opts.key(t)).collect::<Vec<_>>(), &tb.iter().map(|t| opts.key(t)).collect::<Vec<_>>());
     let mut p = Paragraph::new();
     p.props = b.props.clone();
     let base = a.runs.first().map(|r| r.props.clone()).unwrap_or_default();
@@ -723,7 +1116,8 @@ fn word_diff(a: &Paragraph, b: &Paragraph, ins: u32, del: u32) -> Paragraph {
         let at = p.len();
         match op {
             Op::Same => {
-                let _ = p.insert_text(at, ta.get(i).map(String::as_str).unwrap_or(""), &base);
+                // Equal as compared (perhaps up to case or spacing): the revised text.
+                let _ = p.insert_text(at, tb.get(j).map(String::as_str).unwrap_or(""), &base);
                 i += 1;
                 j += 1;
             }
@@ -741,49 +1135,8 @@ fn word_diff(a: &Paragraph, b: &Paragraph, ins: u32, del: u32) -> Paragraph {
 }
 
 fn accessibility(s: &mut Session, _: &Value) -> CmdResult {
-    let mut issues = Vec::new();
-    let mut last_level: Option<u8> = None;
-    for path in s.doc.para_paths(StoryRef::Body) {
-        let Some(p) = s.doc.para(StoryRef::Body, &path) else { continue };
-        for o in &p.objects {
-            if let InlineObject::Image { alt, .. } = o
-                && alt.trim().is_empty()
-            {
-                issues.push(json!({"kind": "error", "issue": "Missing alternative text", "where": path.0, "fix": "Select the picture and run picture.altText"}));
-            }
-            // Charts and diagrams can't be given alt text yet (see objects.rs), so only report them.
-            if let InlineObject::Graphic { alt, .. } = o
-                && alt.trim().is_empty()
-            {
-                issues.push(json!({"kind": "error", "issue": "Chart or diagram has no alternative text", "where": path.0}));
-            }
-        }
-        if let Some(l) = s.doc.styles.resolve_para(&p.props).outline_level {
-            if let Some(prev) = last_level
-                && l > prev + 1
-            {
-                issues.push(json!({"kind": "warning", "issue": format!("Heading level skipped (Heading {} after Heading {})", l + 1, prev + 1), "where": path.0}));
-            }
-            last_level = Some(l);
-        }
-        if p.runs.iter().any(|r| r.props.link.is_some()) {
-            let txt = p.plain_text().to_lowercase();
-            if txt.contains("click here") {
-                issues.push(json!({"kind": "tip", "issue": "Link text \"click here\" isn't descriptive", "where": path.0}));
-            }
-        }
-    }
-    for (i, b) in s.doc.body.iter().enumerate() {
-        if let Block::Table(t) = &**b
-            && !t.rows.first().is_some_and(|r| r.props.header)
-        {
-            issues.push(json!({"kind": "warning", "issue": "Table has no header row", "where": [i], "fix": "table.repeatHeader on the first row"}));
-        }
-    }
-    if s.doc.core.title.is_empty() {
-        issues.push(json!({"kind": "tip", "issue": "Document has no title", "fix": "file.properties {title}"}));
-    }
-    Ok(json!({"issues": issues, "ok": issues.is_empty()}))
+    let issues = super::accessibility::check(&s.doc);
+    Ok(json!({"ok": issues.is_empty(), "issues": issues}))
 }
 
 fn inspect_doc(s: &mut Session, v: &Value) -> CmdResult {
@@ -1025,34 +1378,6 @@ fn customize_ribbon(s: &mut Session, v: &Value) -> CmdResult {
     Ok(Value::Object(out))
 }
 
-/// Review › Language: the proofing language of the selection (`lang`, a BCP 47 tag such as
-/// `pl-PL`; `en-US` when neither `lang` nor `noProof` is given), and/or whether it is checked at
-/// all (`noProof`). With `default`, `lang` also becomes the document's default language (its
-/// default run formatting, `w:docDefaults` in .docx): text with no language of its own follows.
-fn set_language(s: &mut Session, v: &Value) -> CmdResult {
-    let no_proof = p::bool(v, "noProof");
-    let lang = match p::str(v, "lang") {
-        Some(t) => Some(
-            wordcraft_proof::lang::normalize_tag(t)
-                .ok_or_else(|| CmdError::Params(format!("`lang` must be a language tag such as pl-PL or en-US, not {t:?}")))?,
-        ),
-        None if no_proof.is_some() => None,
-        None => Some("en-US".to_string()),
-    };
-    if p::bool(v, "default") == Some(true) {
-        let Some(l) = &lang else { return Err(CmdError::Params("`default` needs `lang`".into())) };
-        s.doc.styles.default_chr.lang = Some(l.clone());
-    }
-    super::format::apply(s, &|c| {
-        if let Some(l) = &lang {
-            c.lang = Some(l.clone());
-        }
-        if let Some(np) = no_proof {
-            c.no_proof = Some(np);
-        }
-    })
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -1066,6 +1391,38 @@ mod tests {
         assert_eq!(s.doc.plain_text(StoryRef::Body), "The dog sat.\nKeep this.\nNew line here.");
     }
 
+    #[test]
+    fn compare_options_ignore_case_and_white_space() {
+        let original = "The Cat sat.\nTwo  spaces here.";
+        let revised = "The cat sat.\nTwo spaces here.";
+        // By default both differences are changes.
+        let mut s = Session::new(Document::from_text(original));
+        let r = s.run("review.compare", &json!({"text": revised, "author": "Reviewer"})).unwrap();
+        assert_eq!(r["changes"], 2);
+        assert!(s.doc.revisions.iter().any(|x| x.author == "Reviewer"));
+        // Ignoring case and white space: no changes, and the result reads as the revised text.
+        let mut s = Session::new(Document::from_text(original));
+        let r = s.run("review.compare", &json!({"text": revised, "caseChanges": false, "whiteSpace": false})).unwrap();
+        assert_eq!(r["changes"], 0);
+        assert_eq!(s.doc.plain_text(StoryRef::Body), revised);
+        // Character level marks only the changed letters.
+        let mut s = Session::new(Document::from_text("colour"));
+        s.run("review.compare", &json!({"text": "color", "level": "character"})).unwrap();
+        let p = s.doc.body[0].as_para().unwrap();
+        let deleted: String = p.run_ranges().filter(|(_, c)| c.del.is_some()).map(|(r, _)| p.text[r].to_string()).collect();
+        assert_eq!(deleted, "u");
+        // Formatting differences become formatting changes.
+        let mut s = Session::new(Document::from_text("Same words."));
+        let mut rev = Document::from_text("Same words.");
+        rev.format_range(&rev.start_of(StoryRef::Body), &rev.end_of(StoryRef::Body), &|c| c.bold = Some(true)).unwrap();
+        let path = std::env::temp_dir().join(format!("wc-compare-{}.docx", std::process::id()));
+        crate::io::save_path(&path, &rev).unwrap();
+        let r = s.run("review.compare", &json!({"path": path.to_string_lossy()})).unwrap();
+        let _ = std::fs::remove_file(&path);
+        assert_eq!(r["changes"], 1);
+        assert!(s.doc.revisions.iter().any(|x| x.kind == RevisionKind::Format));
+    }
+
     #[test]
     fn macros_record_and_run() {
         let mut s = Session::new(Document::new());
@@ -1108,4 +1465,19 @@ mod tests {
         s.run("insert.quickParts", &json!({"insert": "m"})).unwrap();
         assert!(s.doc.plain_text(StoryRef::Body).ends_with("Membership"));
     }
+
+    /// #407 Language: the selection's language and "do not check", the default language and
+    /// the detect preference; a bad tag is refused.
+    #[test]
+    fn proofing_language_options() {
+        let mut s = Session::new(Document::from_text("Bonjour"));
+        s.run("select.all", &json!({})).unwrap();
+        s.run("review.language", &json!({"lang": "fr-FR", "noProof": true, "detect": false})).unwrap();
+        let rc = s.doc.para_at(&Pos::body(0, 1)).map(|p| p.props_at(1).clone()).unwrap();
+        assert_eq!((rc.lang.as_deref(), rc.no_proof), (Some("fr-FR"), Some(true)));
+        assert!(!s.prefs.detect_language);
+        s.run("review.language", &json!({"lang": "de-DE", "default": true})).unwrap();
+        assert_eq!(s.doc.styles.default_chr.lang.as_deref(), Some("de-DE"));
+        assert!(s.run("review.language", &json!({"lang": "<script>"})).is_err());
+    }
 }
diff --git a/crates/engine/src/cmd/view.rs b/crates/engine/src/cmd/view.rs
index 42a9ecfbd5..1e2e0cfcef 100644
--- a/crates/engine/src/cmd/view.rs
+++ b/crates/engine/src/cmd/view.rs
@@ -24,14 +24,13 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("view.printLayout", "Print Layout", "View › Views", |s, _| mode(s, ViewMode::Print, false)).key("Mod+Alt+P").pure(),
         CommandSpec::new("view.webLayout", "Web Layout", "View › Views", |s, _| mode(s, ViewMode::Web, false)).pure(),
         CommandSpec::new("view.draft", "Draft", "View › Views", |s, _| mode(s, ViewMode::Draft, false)).key("Mod+Alt+N").pure(),
-        CommandSpec::new("view.outline", "Outline", "View › Views", |s, _| {
-            mode(s, ViewMode::Draft, false)?;
-            s.view.nav_pane = true;
-            sel_result(s)
-        })
-        .key("Mod+Alt+O")
-        .pure(),
+        // The body as an outline of its headings, with the Outlining tab (`outline.*`).
+        CommandSpec::new("view.outline", "Outline", "View › Views", |s, _| mode(s, ViewMode::Outline, false)).key("Mod+Alt+O").pure(),
         CommandSpec::new("view.readMode", "Read Mode", "View › Views", |s, _| mode(s, ViewMode::Print, true)).pure(),
+        // Print Layout: hide the white space (margins, headers, footers) between pages. Screen only.
+        CommandSpec::new("view.hideWhiteSpace", "Hide White Space", "View › Show", |s, v| toggle(s, v, |x| &mut x.hide_white_space))
+            .params(r#"{"value"?: bool}"#)
+            .pure(),
         CommandSpec::new("view.focus", "Focus", "View › Immersive", |s, v| toggle(s, v, |x| &mut x.focus_mode)).pure(),
         CommandSpec::new("view.ruler", "Ruler", "View › Show", |s, v| toggle(s, v, |x| &mut x.ruler)).pure(),
         // The drawing grid over the page (screen only; never printed or exported).
@@ -63,6 +62,14 @@ pub fn specs() -> Vec<CommandSpec> {
         CommandSpec::new("view.darkMode", "Switch Modes", "View › Dark Mode", |s, v| toggle(s, v, |x| &mut x.dark_mode)).pure(),
         CommandSpec::new("view.stylesPane", "Styles Pane", "Home › Styles", |s, v| toggle(s, v, |x| &mut x.styles_pane)).pure(),
         CommandSpec::new("view.commentsPane", "Comments Pane", "Review › Comments", |s, v| toggle(s, v, |x| &mut x.comments_pane)).pure(),
+        CommandSpec::new("view.accessibilityPane", "Accessibility Pane", "Review › Accessibility", |s, v| {
+            toggle(s, v, |x| &mut x.accessibility_pane)
+        })
+        .params(r#"{"value"?: bool}"#)
+        .pure(),
+        CommandSpec::new("view.altTextPane", "Alt Text Pane", "Review › Accessibility", |s, v| toggle(s, v, |x| &mut x.alt_text_pane))
+            .params(r#"{"value"?: bool}"#)
+            .pure(),
         CommandSpec::new("view.newWindow", "New Window", "View › Window", |s, _| {
             s.ui_requests.push(json!({"open": "newWindow"}));
             sel_result(s)
diff --git a/crates/engine/src/cmd/wordart.rs b/crates/engine/src/cmd/wordart.rs
new file mode 100644
index 0000000000..fe3883b5d5
--- /dev/null
+++ b/crates/engine/src/cmd/wordart.rs
@@ -0,0 +1,319 @@
+//! WordArt: Insert › WordArt, Home › Font › Text Effects, and Shape Format › WordArt Styles (our
+//! own styles in theme colours, text fill, text outline, Transform).
+//!
+//! Text effects are run properties ([`wordcraft_doc::wordart::TextEffects`]); a Transform is the
+//! text warp of a shape ([`wordcraft_doc::wordart::TextWarp`]). With a shape selected, or the
+//! caret in a text box, the effects apply to the whole box's text, as WordArt is formatted.
+
+use serde_json::{Value, json};
+use wordcraft_doc::effects::{Glow, Shadow};
+use wordcraft_doc::para::{Anchor, Float, FloatAlign, InlineObject, OBJ, ShapeKind, Wrap};
+use wordcraft_doc::props::{CharProps, Rgb};
+use wordcraft_doc::wordart::{GradStop, Reflection, TextEffects, TextFill, TextOutline, TextWarp, art_style};
+use wordcraft_doc::{Paragraph, PartKind, Pos, StoryRef, para_block};
+
+use super::sel_result;
+use crate::{CmdError, CmdResult, CommandSpec, Selection, Session, p};
+
+const EFFECT_PARAMS: &str = r#"{"style"?: "solid"|"outlined"|"hollow"|"gradient"|"shadowed"|"glowing"|"reflected"|"sunset", "clear"?: bool, "fill"?: "RRGGBB"|"none" (hollow)|{"color": "RRGGBB", "transparency"?: %}|{"gradient": ["RRGGBB", …], "angle"?: deg}|null (the run's colour), "outline"?: "RRGGBB"|"none"|{"color"?: "RRGGBB"|null, "width"?: pt, "transparency"?: %}|null, "shadow"?: preset|{"color"?, "transparency"?, "blur"?, "distance"?, "angle"?}|null, "glow"?: pt|{"color"?, "size"?, "transparency"?}|null, "reflection"?: bool|{"transparency"?: %, "size"?: %, "distance"?: pt}|null}  (an omitted key is left as it is; with a shape selected or the caret in a text box, the box's whole text)"#;
+
+pub fn specs() -> Vec<CommandSpec> {
+    vec![
+        CommandSpec::new("insert.wordArt", "WordArt", "Insert › Text", insert).params(
+            r#"{"text"?: string, "style"?: WordArt style id (see format.textEffects), "transform"?: "textArchUp"|"textArchDown"|"textCircle"|"textWave1"|… (a DrawingML preset text warp)}"#,
+        ),
+        CommandSpec::new("format.textEffects", "Text Effects", "Home › Font", text_effects).params(EFFECT_PARAMS),
+        CommandSpec::new("wordArt.style", "WordArt Styles", "Shape Format › WordArt Styles", |s, v| {
+            let id = p::req_str(v, "style")?;
+            text_effects(s, &json!({"style": id}))
+        })
+        .params(r#"{"style": "solid"|"outlined"|"hollow"|"gradient"|"shadowed"|"glowing"|"reflected"|"sunset"}"#),
+        CommandSpec::new("wordArt.textFill", "Text Fill", "Shape Format › WordArt Styles", |s, v| {
+            text_effects(s, &json!({"fill": v.get("fill").or_else(|| v.get("color")).cloned().unwrap_or(Value::Null)}))
+        })
+        .params(r#"{"fill": "RRGGBB"|"none"|{"gradient": ["RRGGBB", …], "angle"?: deg}|null}"#),
+        CommandSpec::new("wordArt.textOutline", "Text Outline", "Shape Format › WordArt Styles", |s, v| {
+            text_effects(s, &json!({"outline": v.get("outline").cloned().unwrap_or_else(|| v.clone())}))
+        })
+        .params(r#"{"color"?: "RRGGBB"|null, "width"?: pt} or {"outline": "none"|null}"#),
+        CommandSpec::new("wordArt.transform", "Transform", "Shape Format › WordArt Styles", transform)
+            .params(r#"{"preset": "textArchUp"|"textArchDown"|"textCircle"|"textWave1"|"textSlantUp"|"textSlantDown"|"textInflate"|"textDeflate"|"textChevron"|"textChevronInverted"|"textTriangle"|"textTriangleInverted"|… (any DrawingML preset text warp)|"none", "adj"?: n (the preset's adjust value)}"#),
+    ]
+}
+
+/// The theme's colours (dk1, lt1, dk2, lt2, accent1…6, …).
+fn theme(s: &Session) -> Vec<Rgb> {
+    s.doc.settings.theme_colors.clone()
+}
+
+/// The text box story the selection formats as a whole: the selected shape's, or the one the
+/// caret is in.
+fn box_story(s: &Session) -> Option<u32> {
+    if let Some((_, InlineObject::Shape { story: Some(id), .. })) = super::objects::object_selection(s) {
+        return Some(*id);
+    }
+    match s.sel.focus.story {
+        StoryRef::Part(id) if s.sel.is_collapsed() && s.doc.parts.get(&id).is_some_and(|p| p.kind == PartKind::TextBox) => Some(id),
+        _ => None,
+    }
+}
+
+/// Apply `f` to the selection's characters (a text box's whole text: see [`box_story`]).
+fn apply(s: &mut Session, f: &dyn Fn(&mut CharProps)) -> CmdResult {
+    if let Some(id) = box_story(s) {
+        let (a, b) = (s.doc.start_of(StoryRef::Part(id)), s.doc.end_of(StoryRef::Part(id)));
+        s.doc.format_range(&a, &b, f)?;
+        return sel_result(s);
+    }
+    super::format::apply(s, f)
+}
+
+fn color(v: &Value, k: &str) -> Option<Rgb> {
+    p::str(v, k).and_then(Rgb::parse)
+}
+
+/// A change to one effect: `None` leaves it, `Some(None)` removes it.
+type Change<T> = Option<Option<T>>;
+
+fn parse_fill(v: Option<&Value>) -> Result<Change<TextFill>, CmdError> {
+    let bad = || CmdError::Params("`fill`: a colour, \"none\", an object or null".into());
+    Ok(match v {
+        None => None,
+        Some(Value::Null) => Some(None),
+        Some(Value::String(x)) if x == "none" => Some(Some(TextFill::None)),
+        Some(Value::String(x)) => Some(Some(TextFill::Solid { color: Rgb::parse(x).ok_or_else(bad)?, transparency: 0.0 })),
+        Some(o @ Value::Object(_)) => match o.get("gradient").and_then(Value::as_array) {
+            Some(cols) => {
+                let cols: Vec<Rgb> = cols.iter().filter_map(Value::as_str).filter_map(Rgb::parse).take(wordcraft_doc::wordart::MAX_STOPS).collect();
+                let n = cols.len().max(2) as f32 - 1.0;
+                let stops = cols.iter().enumerate().map(|(i, c)| GradStop { pos: 100.0 * i as f32 / n, color: *c, transparency: 0.0 }).collect();
+                Some(TextFill::Gradient { stops, angle: p::f32(o, "angle").unwrap_or(90.0) }.sanitized())
+            }
+            None => Some(Some(TextFill::Solid { color: color(o, "color").ok_or_else(bad)?, transparency: p::f32(o, "transparency").unwrap_or(0.0) })),
+        },
+        Some(_) => return Err(bad()),
+    })
+}
+
+fn parse_outline(v: Option<&Value>) -> Result<Change<TextOutline>, CmdError> {
+    let d = TextOutline::default();
+    Ok(match v {
+        None => None,
+        Some(Value::Null) => Some(None),
+        Some(Value::String(x)) if x == "none" => Some(Some(TextOutline { color: None, ..d })),
+        Some(Value::String(x)) => {
+            Some(Some(TextOutline { color: Some(Rgb::parse(x).ok_or_else(|| CmdError::Params("`outline`: a colour".into()))?), ..d }))
+        }
+        Some(o @ Value::Object(_)) => Some(Some(TextOutline {
+            color: match o.get("color") {
+                Some(Value::Null) => None,
+                Some(_) => color(o, "color").or(d.color),
+                None => d.color,
+            },
+            width: p::f32(o, "width").unwrap_or(d.width),
+            transparency: p::f32(o, "transparency").unwrap_or(0.0),
+        })),
+        Some(_) => return Err(CmdError::Params("`outline`: a colour, \"none\", an object or null".into())),
+    })
+}
+
+fn parse_shadow(v: Option<&Value>) -> Result<Change<Shadow>, CmdError> {
+    let preset = |id: &str| Shadow::preset(id).ok_or_else(|| CmdError::Params(format!("unknown shadow preset `{id}`")));
+    Ok(match v {
+        None => None,
+        Some(Value::Null) => Some(None),
+        Some(Value::Bool(b)) => Some(b.then(Shadow::default)),
+        Some(Value::String(id)) if id == "none" => Some(None),
+        Some(Value::String(id)) => Some(Some(preset(id)?)),
+        Some(o @ Value::Object(_)) => {
+            let mut sh = match p::str(o, "preset") {
+                Some(id) => preset(id)?,
+                None => Shadow::default(),
+            };
+            sh.color = color(o, "color").unwrap_or(sh.color);
+            sh.transparency = p::f32(o, "transparency").unwrap_or(sh.transparency);
+            sh.blur = p::f32(o, "blur").unwrap_or(sh.blur);
+            sh.distance = p::f32(o, "distance").unwrap_or(sh.distance);
+            sh.angle = p::f32(o, "angle").unwrap_or(sh.angle);
+            Some(Some(sh.sanitized()))
+        }
+        Some(_) => return Err(CmdError::Params("`shadow`: a preset name, an object or null".into())),
+    })
+}
+
+fn parse_glow(v: Option<&Value>, accent: Rgb) -> Result<Change<Glow>, CmdError> {
+    let d = Glow { color: accent, ..Glow::default() };
+    Ok(match v {
+        None => None,
+        Some(Value::Null) => Some(None),
+        Some(Value::String(x)) if x == "none" => Some(None),
+        Some(n @ Value::Number(_)) => Some(Some(Glow { size: n.as_f64().unwrap_or(0.0) as f32, ..d }.sanitized()).filter(|g| g.size > 0.0)),
+        Some(o @ Value::Object(_)) => Some(
+            Some(
+                Glow {
+                    color: color(o, "color").unwrap_or(d.color),
+                    size: p::f32(o, "size").unwrap_or(d.size),
+                    transparency: p::f32(o, "transparency").unwrap_or(d.transparency),
+                }
+                .sanitized(),
+            )
+            .filter(|g| g.size > 0.0),
+        ),
+        Some(_) => return Err(CmdError::Params("`glow`: a size in points, an object or null".into())),
+    })
+}
+
+fn parse_reflection(v: Option<&Value>) -> Result<Change<Reflection>, CmdError> {
+    let d = Reflection::default();
+    Ok(match v {
+        None => None,
+        Some(Value::Null) => Some(None),
+        Some(Value::Bool(b)) => Some(b.then_some(d)),
+        Some(o @ Value::Object(_)) => Some(Some(Reflection {
+            transparency: p::f32(o, "transparency").unwrap_or(d.transparency),
+            size: p::f32(o, "size").unwrap_or(d.size),
+            distance: p::f32(o, "distance").unwrap_or(d.distance),
+            blur: p::f32(o, "blur").unwrap_or(d.blur),
+        })),
+        Some(_) => return Err(CmdError::Params("`reflection`: true, an object or null".into())),
+    })
+}
+
+/// `format.textEffects`: set or clear the WordArt effects of the selection.
+fn text_effects(s: &mut Session, v: &Value) -> CmdResult {
+    let theme = theme(s);
+    let accent = theme.get(4).copied().unwrap_or(Rgb(0x15, 0x60, 0x82));
+    let style = match p::str(v, "style") {
+        Some(id) => Some(art_style(id, &theme).ok_or_else(|| CmdError::Params(format!("unknown WordArt style `{id}`")))?),
+        None => None,
+    };
+    let clear = p::bool(v, "clear").unwrap_or(false);
+    let fill = parse_fill(v.get("fill"))?;
+    let outline = parse_outline(v.get("outline"))?;
+    let shadow = parse_shadow(v.get("shadow"))?;
+    let glow = parse_glow(v.get("glow"), accent)?;
+    let reflection = parse_reflection(v.get("reflection"))?;
+    let f = |c: &mut CharProps| {
+        let mut fx = if clear { TextEffects::default() } else { c.text_effects.take().map(|b| *b).unwrap_or_default() };
+        if let Some(st) = &style {
+            fx = st.clone();
+        }
+        if let Some(x) = &fill {
+            fx.fill.clone_from(x);
+        }
+        if let Some(x) = outline {
+            fx.outline = x;
+        }
+        if let Some(x) = shadow {
+            fx.shadow = x;
+        }
+        if let Some(x) = glow {
+            fx.glow = x;
+        }
+        if let Some(x) = reflection {
+            fx.reflection = x;
+        }
+        let fx = fx.sanitized();
+        c.text_effects = (!fx.is_empty()).then(|| Box::new(fx));
+    };
+    apply(s, &f)
+}
+
+/// The shape a Transform applies to: the selected one, or the one whose text box the caret is in.
+fn warp_target(s: &Session) -> Option<Pos> {
+    if let Some((pos, InlineObject::Shape { .. })) = super::objects::object_selection(s) {
+        return Some(pos);
+    }
+    let StoryRef::Part(id) = s.sel.focus.story else { return None };
+    let at = s.doc.text_box_anchor(id)?;
+    Some(Pos { off: at.off.checked_sub(OBJ.len_utf8())?, ..at })
+}
+
+/// `wordArt.transform`: bend the shape's text along a preset warp, or straighten it.
+fn transform(s: &mut Session, v: &Value) -> CmdResult {
+    let preset = p::req_str(v, "preset")?;
+    let warp = match preset {
+        "none" => None,
+        id => {
+            let mut w = TextWarp::new(id).ok_or_else(|| CmdError::Params(format!("unknown text warp `{id}`")))?;
+            if let Some(a) = v.get("adj").and_then(Value::as_f64).filter(|a| a.is_finite()) {
+                w.set_adj("adj", a.clamp(-1e12, 1e12) as i64);
+            }
+            Some(w)
+        }
+    };
+    let pos = warp_target(s).ok_or_else(|| CmdError::Disabled("select a shape or WordArt first".into()))?;
+    let para = s.doc.para_mut(pos.story, &pos.path)?;
+    match para.object_at_mut(pos.off) {
+        Some(InlineObject::Shape { extra, .. }) => extra.warp = warp.clone(),
+        _ => return Err(CmdError::Disabled("select a shape or WordArt first".into())),
+    }
+    para.touch();
+    Ok(json!({"transform": warp.map(|w| w.preset)}))
+}
+
+/// How wide `text` is at `size` points in the document's body font, points.
+fn text_width(s: &Session, text: &str, size: f32, bold: bool) -> f32 {
+    let family = s.doc.styles.default_chr.font.clone().unwrap_or_else(|| s.doc.settings.minor_font.clone());
+    let face = wordcraft_fonts::word::resolve(&family, bold, false).face;
+    let k = size / face.upem.max(1.0) as f32;
+    wordcraft_fonts::shape(&face, text, &[], |c| c).iter().map(|g| g.x_advance as f32 * k).sum::<f32>()
+}
+
+/// `insert.wordArt`: a floating text box without fill or line, its text in a WordArt style (and
+/// optionally bent), centred on the column at the caret's paragraph; its text is selected so
+/// typing replaces it.
+fn insert(s: &mut Session, v: &Value) -> CmdResult {
+    let text: String = p::str(v, "text").unwrap_or("Your text here").chars().filter(|c| !c.is_control()).take(1000).collect();
+    let text = if text.trim().is_empty() { "Your text here".to_string() } else { text };
+    let style = p::str(v, "style").unwrap_or("solid");
+    let fx = art_style(style, &theme(s)).ok_or_else(|| CmdError::Params(format!("unknown WordArt style `{style}`")))?;
+    let warp = match p::str(v, "transform") {
+        None | Some("none") => None,
+        Some(id) => Some(TextWarp::new(id).ok_or_else(|| CmdError::Params(format!("unknown text warp `{id}`")))?),
+    };
+    let size = 36.0;
+    let props = CharProps { size: Some(size), bold: Some(true), text_effects: Some(Box::new(fx)), ..Default::default() };
+    // A box the text fits on one line in (with the box's margins); a bent one is taller.
+    let col = s.doc.sections().first().map(|(_, sp)| sp.text_width()).unwrap_or(468.0);
+    let w = (text_width(s, &text, size, true) + 24.0).clamp(72.0, col.max(72.0));
+    let mut h = size * 1.35 + 7.2;
+    if let Some(wp) = &warp {
+        h = match wp.preset.as_str() {
+            "textCircle" => w,
+            "textArchUp" | "textArchDown" => w * 0.5,
+            _ => h * 1.6,
+        };
+    }
+    let id = s.doc.add_part(PartKind::TextBox, vec![para_block(Paragraph::with_text(&text, props))]);
+    if let Some(p) = s.doc.parts.get_mut(&id)
+        && let Some(b) = p.blocks.first_mut()
+        && let wordcraft_doc::Block::Para(para) = std::sync::Arc::make_mut(b)
+    {
+        para.props.align = Some(wordcraft_doc::props::Align::Center);
+    }
+    let obj = InlineObject::Shape {
+        kind: ShapeKind::TextBox,
+        w,
+        h: h.clamp(18.0, 2000.0),
+        fill: None,
+        stroke: None,
+        stroke_width: 0.0,
+        float: Float {
+            wrap: Wrap::InFrontOfText,
+            h_rel: Anchor::Margin,
+            h_align: Some(FloatAlign::Center),
+            v_rel: Anchor::Paragraph,
+            ..Default::default()
+        },
+        story: Some(id),
+        freeform: None,
+        effects: Default::default(),
+        extra: wordcraft_doc::connector::ShapeExtra { warp, ..Default::default() },
+    };
+    let typing = s.typing_props();
+    let at = super::delete_selection(s)?;
+    s.doc.insert_object(&at, obj, &typing)?;
+    s.sel = Selection { anchor: s.doc.start_of(StoryRef::Part(id)), focus: s.doc.end_of(StoryRef::Part(id)) };
+    Ok(json!({"story": id}))
+}
diff --git a/crates/engine/src/io.rs b/crates/engine/src/io.rs
index 6de19524cd..f3fc258190 100644
--- a/crates/engine/src/io.rs
+++ b/crates/engine/src/io.rs
@@ -2,6 +2,9 @@
 
 use wordcraft_doc::Document;
 
+#[cfg(not(target_arch = "wasm32"))]
+mod safe_save;
+
 /// Formats WordCraft opens.
 pub const OPEN_EXTS: &[&str] = &[
     "docx",
@@ -20,15 +23,18 @@ pub const OPEN_EXTS: &[&str] = &[
     "tex",
     "latex",
     "ltx",
+    "xml",
     "wcraft.json",
     "json",
 ];
 /// Formats WordCraft saves (Save As).
-pub const SAVE_EXTS: &[&str] = &["docx", "docm", "dotx", "dotm", "pdf", "txt", "md", "html", "rtf", "odt", "tex", "png", "json"];
+pub const SAVE_EXTS: &[&str] = &["docx", "docm", "dotx", "dotm", "pdf", "txt", "md", "html", "rtf", "odt", "tex", "png", "json", "xml"];
 
+/// The extension of a file name or path, lower-case; empty when the file name has none (a dot
+/// in a folder name doesn't count).
 fn ext_of(name: &str) -> String {
-    let lower = name.to_ascii_lowercase();
-    lower.rsplit('.').next().unwrap_or("").to_string()
+    let file = name.rsplit(['/', '\\']).next().unwrap_or(name);
+    file.rsplit_once('.').map(|(_, ext)| ext.to_ascii_lowercase()).unwrap_or_default()
 }
 
 /// Is `ext` one of Word's package formats (.docx/.docm/.dotx/.dotm), which save without loss?
@@ -36,6 +42,17 @@ pub fn is_word_package(ext: &str) -> bool {
     wordcraft_docx::Flavor::from_ext(ext).is_some()
 }
 
+/// How a copy in another format is written.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ExportOptions {
+    /// Print Markup: PDFs show tracked changes marked up and, with `comments`, each page scaled
+    /// down beside a markup area with the comments in balloons (page images get the area too);
+    /// HTML, Markdown and text copies end with the comments.
+    pub markup: bool,
+    /// With `markup`, show the comments (Track Changes Options › Comments).
+    pub comments: bool,
+}
+
 /// A document password: wiped from memory when dropped, never printed (`Debug` shows `***`).
 #[derive(Clone, Default, PartialEq, Eq)]
 pub struct Password(zeroize::Zeroizing<String>);
@@ -93,27 +110,64 @@ pub fn open_bytes_with(name: &str, bytes: &[u8], password: Option<&str>) -> Resu
         doc.ensure_nonempty();
         return Ok((doc, true));
     }
+    if ext.is_empty() {
+        return open_by_content(name, &ext, bytes, password);
+    }
     let mut doc = match ext.as_str() {
         // Plain text goes through the formats importer: BOMs, unmarked UTF-16, Windows-1252.
         "txt" | "text" | "" => wordcraft_formats::txt::import(bytes),
         "json" => serde_json::from_slice::<Document>(bytes).map_err(|e| format!("{name}: {e}"))?,
         other => match crate::io_ext::open(other, bytes) {
             Some(r) => r?,
-            None => return Err(format!("{name}: unsupported format `.{other}`")),
+            None => return open_by_content(name, other, bytes, password),
         },
     };
     doc.ensure_nonempty();
     Ok((doc, false))
 }
 
+/// A file whose extension names no format WordCraft knows (`.m3u`, `.log`, `.ini`, none…),
+/// opened by what it holds, as Word does: a Word document or RTF file by its signature, any
+/// other text through the plain-text import with encoding detection (#569). Anything else is
+/// refused with a clear error rather than shown as garbage.
+fn open_by_content(name: &str, ext: &str, bytes: &[u8], password: Option<&str>) -> Result<(Document, bool), String> {
+    const ZIP: &[u8] = b"PK\x03\x04";
+    const OLE: &[u8] = &[0xD0, 0xCF, 0x11, 0xE0, 0xA1, 0xB1, 0x1A, 0xE1];
+    let (mut doc, encrypted) = if bytes.starts_with(OLE) && wordcraft_docx::is_encrypted(bytes) {
+        (wordcraft_docx::read_with_password(bytes, password).map_err(|e| e.to_string())?, true)
+    } else if bytes.starts_with(ZIP) {
+        (wordcraft_docx::read(bytes).map_err(|e| format!("{name}: not a document WordCraft can open ({e})"))?, false)
+    } else if bytes.starts_with(OLE) {
+        (wordcraft_docbin::read(bytes).map_err(|e| format!("{name}: not a document WordCraft can open ({e})"))?, false)
+    } else if bytes.starts_with(b"{\\rtf") {
+        (wordcraft_formats::rtf::import(bytes)?, false)
+    } else if wordcraft_formats::txt::is_text(bytes) {
+        (wordcraft_formats::txt::import(bytes), false)
+    } else if ext.is_empty() {
+        return Err(format!("{name}: not a document or text file WordCraft can open"));
+    } else {
+        return Err(format!("{name}: unsupported format `.{ext}` (not a document or text file)"));
+    };
+    doc.ensure_nonempty();
+    Ok((doc, encrypted))
+}
+
 /// Serialise a document; `name` gives the format by extension.
 pub fn save_bytes(name: &str, doc: &Document) -> Result<Vec<u8>, String> {
+    save_bytes_opts(name, doc, &ExportOptions::default())
+}
+
+/// [`save_bytes`] with export options (Print Markup).
+pub fn save_bytes_opts(name: &str, doc: &Document, opts: &ExportOptions) -> Result<Vec<u8>, String> {
     let ext = ext_of(name);
     match ext.as_str() {
         // List paragraphs get their label and a tab, as in Word's plain-text save.
-        "txt" | "text" => Ok(wordcraft_formats::txt::export(doc)),
+        "txt" | "text" => {
+            let bytes = wordcraft_formats::txt::export(doc);
+            Ok(if opts.markup && opts.comments { wordcraft_formats::comments::append("txt", doc, bytes) } else { bytes })
+        }
         "json" => serde_json::to_vec_pretty(doc).map_err(|e| e.to_string()),
-        other => match crate::io_ext::save(other, doc) {
+        other => match crate::io_ext::save(other, doc, opts) {
             Some(r) => r,
             None => Err(format!("{name}: can't save as `.{other}`")),
         },
@@ -122,8 +176,8 @@ pub fn save_bytes(name: &str, doc: &Document) -> Result<Vec<u8>, String> {
 
 /// [`save_bytes`], encrypted with `password` when there is one and the format is a Word package
 /// (other formats are copies and are written as they are).
-pub fn save_bytes_with(name: &str, doc: &Document, password: Option<&str>) -> Result<Vec<u8>, String> {
-    let bytes = save_bytes(name, doc)?;
+pub fn save_bytes_with(name: &str, doc: &Document, password: Option<&str>, opts: &ExportOptions) -> Result<Vec<u8>, String> {
+    let bytes = save_bytes_opts(name, doc, opts)?;
     match password {
         Some(pw) if can_encrypt(name) => wordcraft_docx::encrypt(&bytes, pw).map_err(|e| e.to_string()),
         _ => Ok(bytes),
@@ -262,21 +316,18 @@ pub fn open_path_with(path: &std::path::Path, _password: Option<&str>) -> Result
 }
 
 pub fn save_path(path: &std::path::Path, doc: &Document) -> Result<(), String> {
-    save_path_with(path, doc, None)
+    save_path_with(path, doc, None, &ExportOptions::default())
 }
 
 /// [`save_path`], encrypted with `password` as [`save_bytes_with`] does.
 #[cfg(not(target_arch = "wasm32"))]
-pub fn save_path_with(path: &std::path::Path, doc: &Document, password: Option<&str>) -> Result<(), String> {
-    let bytes = save_bytes_with(&path.to_string_lossy(), doc, password)?;
-    // Write atomically: temp file next to the target, then rename.
-    let tmp = path.with_extension(format!("{}.tmp", ext_of(&path.to_string_lossy())));
-    std::fs::write(&tmp, &bytes).map_err(|e| format!("{}: {e}", tmp.display()))?;
-    std::fs::rename(&tmp, path).map_err(|e| format!("{}: {e}", path.display()))
+pub fn save_path_with(path: &std::path::Path, doc: &Document, password: Option<&str>, opts: &ExportOptions) -> Result<(), String> {
+    let bytes = save_bytes_with(&path.to_string_lossy(), doc, password, opts)?;
+    safe_save::write(path, &bytes).map_err(|e| format!("{}: {e}", path.display()))
 }
 
 #[cfg(target_arch = "wasm32")]
-pub fn save_path_with(path: &std::path::Path, _doc: &Document, _password: Option<&str>) -> Result<(), String> {
+pub fn save_path_with(path: &std::path::Path, _doc: &Document, _password: Option<&str>, _opts: &ExportOptions) -> Result<(), String> {
     Err(format!("{}: files are saved through the browser on the web", path.display()))
 }
 
diff --git a/crates/engine/src/io/safe_save.rs b/crates/engine/src/io/safe_save.rs
new file mode 100644
index 0000000000..16c86bd4d6
--- /dev/null
+++ b/crates/engine/src/io/safe_save.rs
@@ -0,0 +1,182 @@
+//! Sibling temporary files owned by one save. The destination changes only after preparation
+//! succeeds; concurrent saves have separate files and the last successful replacement wins.
+use std::fs::{self, File, OpenOptions};
+use std::io::{self, Write};
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+
+pub(super) fn write(path: &Path, bytes: &[u8]) -> io::Result<()> {
+    let permissions = match fs::metadata(path) {
+        Ok(meta) if meta.is_file() => Some(meta.permissions()),
+        Ok(_) => None,
+        Err(e) if e.kind() == io::ErrorKind::NotFound => None,
+        Err(e) => return Err(e),
+    };
+    // A new document gets the usual mode (0666 less the umask); a replaced one keeps its own,
+    // and its temporary file stays private until that mode is applied.
+    let private = permissions.is_some();
+    replace_with(path, private, |file| {
+        file.write_all(bytes)?;
+        if let Some(permissions) = permissions {
+            file.set_permissions(permissions)?;
+        }
+        // Synchronize the prepared file before replacing the destination. Directory durability
+        // and network-filesystem/power-loss guarantees are outside this operation's contract.
+        file.sync_all()
+    })
+}
+
+fn replace_with(path: &Path, private: bool, prepare: impl FnOnce(&mut File) -> io::Result<()>) -> io::Result<()> {
+    let mut temp = Temporary::create(path, private)?;
+    prepare(temp.file()?)?;
+    temp.commit(path)
+}
+
+struct Temporary {
+    path: PathBuf,
+    file: Option<File>,
+    committed: bool,
+}
+
+impl Temporary {
+    /// `private`: create the file readable by its owner only (0600) rather than with the default
+    /// mode (0666 less the umask).
+    fn create(destination: &Path, private: bool) -> io::Result<Self> {
+        static NEXT: AtomicU64 = AtomicU64::new(0);
+        if destination.file_name().is_none() {
+            return Err(io::Error::new(io::ErrorKind::InvalidInput, "save destination needs a file name"));
+        }
+        // A short name also works beside a destination already at the filename-length limit.
+        for _ in 0..128 {
+            let id = NEXT.fetch_add(1, Ordering::Relaxed);
+            let path = destination.with_file_name(format!(".wordcraft-save-{}-{id}.tmp", std::process::id()));
+            let mut options = OpenOptions::new();
+            options.write(true).create_new(true);
+            #[cfg(unix)]
+            if private {
+                use std::os::unix::fs::OpenOptionsExt;
+                options.mode(0o600);
+            }
+            #[cfg(not(unix))]
+            let _ = private;
+            match options.open(&path) {
+                Ok(file) => return Ok(Self { path, file: Some(file), committed: false }),
+                Err(e) if e.kind() == io::ErrorKind::AlreadyExists => continue,
+                Err(e) => return Err(e),
+            }
+        }
+        Err(io::Error::new(io::ErrorKind::AlreadyExists, "could not create a save temporary file"))
+    }
+
+    fn file(&mut self) -> io::Result<&mut File> {
+        self.file.as_mut().ok_or_else(|| io::Error::other("save temporary file is closed"))
+    }
+
+    fn commit(mut self, destination: &Path) -> io::Result<()> {
+        // Close before replacement, including on Windows.
+        drop(self.file.take());
+        fs::rename(&self.path, destination)?;
+        self.committed = true;
+        Ok(())
+    }
+}
+
+impl Drop for Temporary {
+    fn drop(&mut self) {
+        drop(self.file.take());
+        if !self.committed {
+            // If filesystem permissions change, cleanup can fail too. Never remove a neighbour
+            // or the destination to compensate for a failed save.
+            let _ = fs::remove_file(&self.path);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    struct Scratch(PathBuf);
+    impl Scratch {
+        fn new() -> Self {
+            static NEXT: AtomicU64 = AtomicU64::new(0);
+            let path =
+                std::env::temp_dir().join(format!("wordcraft-save-owner-test-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
+            fs::create_dir(&path).unwrap();
+            Self(path)
+        }
+        fn target(&self) -> PathBuf {
+            self.0.join("original.docx")
+        }
+    }
+    impl Drop for Scratch {
+        fn drop(&mut self) {
+            let _ = fs::remove_dir_all(&self.0);
+        }
+    }
+
+    #[test]
+    fn partial_and_complete_preparation_failures_leave_original_and_no_owned_temp() {
+        for partial in [true, false] {
+            let d = Scratch::new();
+            let path = d.target();
+            fs::write(&path, b"Original bytes.").unwrap();
+            let err = replace_with(&path, true, |file| {
+                file.write_all(if partial { b"Partial" } else { b"Complete replacement bytes." })?;
+                Err(io::Error::other("injected preparation failure"))
+            })
+            .unwrap_err();
+            assert!(err.to_string().contains("injected"));
+            assert_eq!(fs::read(&path).unwrap(), b"Original bytes.");
+            assert_eq!(fs::read_dir(&d.0).unwrap().count(), 1);
+        }
+    }
+
+    #[test]
+    fn overlapping_prepared_saves_keep_separate_bytes_and_commit_complete_files() {
+        let d = Scratch::new();
+        let path = d.target();
+        fs::write(&path, b"Original bytes.").unwrap();
+        let mut first = Temporary::create(&path, true).unwrap();
+        let mut second = Temporary::create(&path, true).unwrap();
+        assert_ne!(first.path, second.path);
+        first.file().unwrap().write_all(b"First complete save.").unwrap();
+        second.file().unwrap().write_all(b"Second complete save.").unwrap();
+        first.file().unwrap().sync_all().unwrap();
+        second.file().unwrap().sync_all().unwrap();
+        assert_eq!(fs::read(&path).unwrap(), b"Original bytes.");
+        first.commit(&path).unwrap();
+        assert_eq!(fs::read(&path).unwrap(), b"First complete save.");
+        second.commit(&path).unwrap();
+        assert_eq!(fs::read(&path).unwrap(), b"Second complete save.");
+        assert_eq!(fs::read_dir(&d.0).unwrap().count(), 1);
+    }
+
+    #[cfg(unix)]
+    #[test]
+    fn new_temporary_files_are_private_until_prepared() {
+        use std::os::unix::fs::PermissionsExt;
+        let d = Scratch::new();
+        let temp = Temporary::create(&d.target(), true).unwrap();
+        assert_eq!(fs::metadata(&temp.path).unwrap().permissions().mode() & 0o777, 0o600);
+    }
+
+    /// A new document gets the default mode, as `fs::write` would give it — not 0600; a replaced
+    /// document keeps its own mode.
+    #[cfg(unix)]
+    #[test]
+    fn new_documents_get_the_default_mode_and_replaced_ones_keep_theirs() {
+        use std::os::unix::fs::PermissionsExt;
+        let d = Scratch::new();
+        let reference = d.0.join("reference.docx");
+        fs::write(&reference, b"x").unwrap();
+        let default_mode = fs::metadata(&reference).unwrap().permissions().mode() & 0o777;
+        let path = d.target();
+        write(&path, b"New document.").unwrap();
+        assert_eq!(fs::metadata(&path).unwrap().permissions().mode() & 0o777, default_mode);
+        fs::set_permissions(&path, fs::Permissions::from_mode(0o640)).unwrap();
+        write(&path, b"Saved again.").unwrap();
+        assert_eq!(fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o640);
+        assert_eq!(fs::read(&path).unwrap(), b"Saved again.");
+    }
+}
diff --git a/crates/engine/src/io_ext.rs b/crates/engine/src/io_ext.rs
index 6c41656673..a0693d447d 100644
--- a/crates/engine/src/io_ext.rs
+++ b/crates/engine/src/io_ext.rs
@@ -7,26 +7,34 @@ pub fn open(ext: &str, bytes: &[u8]) -> Option<Result<Document, String>> {
     match ext {
         "docx" | "docm" | "dotx" | "dotm" => Some(wordcraft_docx::read(bytes).map_err(|e| e.to_string())),
         "doc" | "dot" => Some(wordcraft_docbin::read(bytes).map_err(|e| e.to_string())),
+        // Word XML Document (Flat OPC) or Word 2003 XML, told apart by the root element.
+        "xml" => Some(wordcraft_docx::read_xml(bytes).map_err(|e| e.to_string())),
         other => wordcraft_formats::import(other, bytes),
     }
 }
 
 /// Save to a format other than plain text / JSON.
-pub fn save(ext: &str, doc: &Document) -> Option<Result<Vec<u8>, String>> {
+pub fn save(ext: &str, doc: &Document, opts: &crate::io::ExportOptions) -> Option<Result<Vec<u8>, String>> {
     // .docx/.docm/.dotx/.dotm: the extension picks the package flavour Word expects.
     if let Some(flavor) = wordcraft_docx::Flavor::from_ext(ext) {
         return Some(wordcraft_docx::write_as(doc, flavor).map_err(|e| e.to_string()));
     }
     match ext {
-        "png" => Some(render_png(doc, 0, 2.0)),
-        "pdf" => Some(wordcraft_pdf::export(doc, &Default::default()).map_err(|e| e.to_string())),
-        other => wordcraft_formats::export(other, doc),
+        "xml" => Some(wordcraft_docx::write_flat(doc).map_err(|e| e.to_string())),
+        "png" => Some(render_png(doc, 0, 2.0, opts)),
+        "pdf" => {
+            let pdf = wordcraft_pdf::PdfOptions { include_markup: opts.markup, comments: opts.markup && opts.comments, ..Default::default() };
+            Some(wordcraft_pdf::export(doc, &pdf).map_err(|e| e.to_string()))
+        }
+        other => wordcraft_formats::export_with(other, doc, &wordcraft_formats::ExportOptions { comments: opts.markup && opts.comments }),
     }
 }
 
-/// Render page `page` as PNG at `scale` px/pt.
-pub fn render_png(doc: &Document, page: usize, scale: f32) -> Result<Vec<u8>, String> {
-    let l = wordcraft_layout::layout(doc, &mut wordcraft_layout::LayoutCache::new(), &Default::default());
+/// Render page `page` as PNG at `scale` px/pt. With Print Markup's comments the page has its
+/// markup area with the comments in balloons (page images always show tracked changes).
+pub fn render_png(doc: &Document, page: usize, scale: f32, opts: &crate::io::ExportOptions) -> Result<Vec<u8>, String> {
+    let lo = wordcraft_layout::LayoutOptions { comment_balloons: opts.markup && opts.comments, ..Default::default() };
+    let l = wordcraft_layout::layout(doc, &mut wordcraft_layout::LayoutCache::new(), &lo);
     let p = l.pages.get(page).ok_or_else(|| format!("no page {}", page + 1))?;
     let img = wordcraft_render::render_page(doc, p, scale, &Default::default());
     Ok(img.to_png())
diff --git a/crates/engine/src/lib.rs b/crates/engine/src/lib.rs
index 38d7df3893..2ec7893010 100644
--- a/crates/engine/src/lib.rs
+++ b/crates/engine/src/lib.rs
@@ -12,6 +12,7 @@ pub mod io;
 mod io_ext;
 pub mod keymap;
 pub mod math_gallery;
+pub mod print;
 pub mod ribbon;
 pub mod sample;
 mod session;
@@ -164,4 +165,8 @@ mod tests;
 #[cfg(test)]
 mod tests_bidi;
 #[cfg(test)]
+mod tests_fonts;
+#[cfg(test)]
 mod tests_typing;
+#[cfg(test)]
+mod tests_wordart;
diff --git a/crates/engine/src/print.rs b/crates/engine/src/print.rs
new file mode 100644
index 0000000000..290dfdb947
--- /dev/null
+++ b/crates/engine/src/print.rs
@@ -0,0 +1,218 @@
+//! Print settings (#641): which pages go out, how many copies, as a PDF.
+//!
+//! WordCraft prints through a PDF (the host opens it in the system's print flow), so the settings
+//! that can be delivered are the ones that shape the PDF: the page range, odd/even pages, copies
+//! and collation. Printer choice, duplex and pages per sheet belong to the OS print dialog.
+//!
+//! Page ranges and copies come from users and control channels, so they are bounded: a range
+//! text is at most [`MAX_SPEC_CHARS`] long, copies are clamped to [`MAX_COPIES`], and the
+//! resulting page list never exceeds [`MAX_PRINT_PAGES`].
+
+use serde_json::{Value, json};
+use wordcraft_layout::DocLayout;
+
+use crate::{CmdError, Session, p};
+
+/// Longest page-range text accepted.
+pub const MAX_SPEC_CHARS: usize = 500;
+/// Most copies one print job asks for.
+pub const MAX_COPIES: u32 = 999;
+/// Most pages (counting copies) one print job holds.
+pub const MAX_PRINT_PAGES: usize = 5000;
+
+/// Parses a custom page range like `1-3, 5, 8-` into 0-based page indexes, in the order typed
+/// (Word prints them in document order; so does this: sorted, without repeats). Pages are
+/// 1-based in the text; `8-` means "to the last page" and `-3` "from the first". An empty text,
+/// page 0, a page past `total`, a reversed range or anything else is an error.
+pub fn parse_page_range(spec: &str, total: usize) -> Result<Vec<usize>, String> {
+    if spec.chars().count() > MAX_SPEC_CHARS {
+        return Err("the page range is too long".into());
+    }
+    if total == 0 {
+        return Err("the document has no pages".into());
+    }
+    let mut keep = vec![false; total];
+    let mut any = false;
+    for item in spec.split([',', ';']) {
+        let item: String = item.chars().filter(|c| !c.is_whitespace()).collect();
+        if item.is_empty() {
+            continue;
+        }
+        let page = |t: &str| -> Result<usize, String> {
+            let n: usize = t.parse().map_err(|_| format!("`{item}` isn't a page or a range like 2-4"))?;
+            if n == 0 || n > total {
+                return Err(format!("page {n} doesn't exist; the document has {total} page{}", if total == 1 { "" } else { "s" }));
+            }
+            Ok(n)
+        };
+        let (from, to) = match item.split_once('-') {
+            None => {
+                let n = page(&item)?;
+                (n, n)
+            }
+            Some(("", "")) => return Err("`-` isn't a page or a range like 2-4".into()),
+            Some((a, b)) => {
+                let from = if a.is_empty() { 1 } else { page(a)? };
+                let to = if b.is_empty() { total } else { page(b)? };
+                if from > to {
+                    return Err(format!("`{item}` runs backwards"));
+                }
+                (from, to)
+            }
+        };
+        for flag in keep.iter_mut().take(to).skip(from - 1) {
+            *flag = true;
+        }
+        any = true;
+    }
+    if !any {
+        return Err("type the pages to print, like 1-3, 5".into());
+    }
+    Ok(keep.iter().enumerate().filter(|(_, k)| **k).map(|(i, _)| i).collect())
+}
+
+/// What a print job holds: the pages (0-based, copies included, in print order).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PrintPlan {
+    /// Page indexes in print order, repeated for copies.
+    pub pages: Vec<usize>,
+    /// Distinct pages chosen (before copies).
+    pub chosen: usize,
+    pub copies: u32,
+}
+
+/// Works out the print plan for `v` against a layout of `total` pages whose caret and selection
+/// sit on pages `current` (first, last). Params:
+/// `range` (`all` | `current` | `selection` | `custom`; `custom` is implied by `pages`),
+/// `pages` (text like `1-3,5`), `parity` (`all` | `odd` | `even`), `copies` (1–999),
+/// `collate` (default true: 1,2,3 1,2,3; false: 1,1,2,2,3,3).
+pub fn plan(v: &Value, total: usize, current: (usize, usize)) -> Result<PrintPlan, CmdError> {
+    let bad = |m: String| CmdError::Params(m);
+    let pages_text = p::str(v, "pages").filter(|t| !t.trim().is_empty());
+    let range = p::str(v, "range").unwrap_or(if pages_text.is_some() { "custom" } else { "all" });
+    let last = total.saturating_sub(1);
+    let mut pages: Vec<usize> = match range {
+        "all" => (0..total).collect(),
+        "current" => vec![current.0.min(last)],
+        "selection" => (current.0.min(last)..=current.1.min(last).max(current.0.min(last))).collect(),
+        "custom" => parse_page_range(pages_text.unwrap_or(""), total).map_err(bad)?,
+        other => return Err(bad(format!("unknown range `{other}`; use all, current, selection or custom"))),
+    };
+    match p::str(v, "parity").unwrap_or("all") {
+        "all" => {}
+        // Page numbers are 1-based: the odd ones are indexes 0, 2, 4…
+        "odd" => pages.retain(|i| i % 2 == 0),
+        "even" => pages.retain(|i| i % 2 == 1),
+        other => return Err(bad(format!("unknown parity `{other}`; use all, odd or even"))),
+    }
+    if pages.is_empty() {
+        return Err(bad("no pages to print with these settings".into()));
+    }
+    let copies = p::u64(v, "copies").unwrap_or(1).clamp(1, u64::from(MAX_COPIES)) as u32;
+    let chosen = pages.len();
+    let total_out = chosen.checked_mul(copies as usize).filter(|n| *n <= MAX_PRINT_PAGES);
+    let Some(total_out) = total_out else {
+        return Err(bad(format!("{chosen} pages × {copies} copies is more than the {MAX_PRINT_PAGES} pages one print job can hold")));
+    };
+    let mut out = Vec::with_capacity(total_out);
+    if p::bool(v, "collate").unwrap_or(true) {
+        for _ in 0..copies {
+            out.extend_from_slice(&pages);
+        }
+    } else {
+        for &pg in &pages {
+            out.extend(std::iter::repeat_n(pg, copies as usize));
+        }
+    }
+    Ok(PrintPlan { pages: out, chosen, copies })
+}
+
+impl Session {
+    /// The pages the caret (or selection) is on, in the output layout: (first, last).
+    pub fn current_pages(&self, lay: &DocLayout) -> (usize, usize) {
+        let (a, b) = self.sel.ordered();
+        let first = lay.caret_on(&a, self.page_hint).map_or(0, |c| c.page);
+        let last = lay.caret_on(&b, self.page_hint).map_or(first, |c| c.page);
+        (first, last.max(first))
+    }
+
+    /// The document as the PDF of a print job `v` describes (see [`plan`]), with the number of
+    /// distinct pages chosen and copies. Does not touch the document.
+    pub fn print_pdf(&self, v: &Value) -> Result<(Vec<u8>, PrintPlan), CmdError> {
+        // Print Markup (File › Print) decides whether tracked changes and comments print.
+        let markup = crate::cmd::file::export_options(self, v);
+        let lay = self.export_layout_with(markup.markup);
+        let plan = plan(v, lay.pages.len(), self.current_pages(&lay))?;
+        let opts = wordcraft_pdf::PdfOptions {
+            pages: Some(plan.pages.clone()),
+            // Repeated pages would repeat the structure tree's entries too.
+            tagged: plan.copies <= 1,
+            include_markup: markup.markup,
+            comments: markup.comments,
+            ..Default::default()
+        };
+        let bytes = wordcraft_pdf::export_layout(&self.doc, &lay, &opts).map_err(|e| CmdError::Failed(e.to_string()))?;
+        Ok((bytes, plan))
+    }
+}
+
+/// `file.printPdf`: write the print job's PDF to `path` (no dialogs).
+pub(crate) fn print_pdf_to_file(s: &mut Session, v: &Value) -> Result<Value, CmdError> {
+    let path = p::req_str(v, "path")?;
+    let path = if path.to_ascii_lowercase().ends_with(".pdf") { path.to_string() } else { format!("{path}.pdf") };
+    let (bytes, plan) = s.print_pdf(v)?;
+    #[cfg(not(target_arch = "wasm32"))]
+    std::fs::write(&path, &bytes).map_err(|e| CmdError::Failed(format!("{path}: {e}")))?;
+    Ok(json!({"path": path, "pages": plan.pages.len(), "chosen": plan.chosen, "copies": plan.copies, "bytes": bytes.len()}))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn ranges_parse_and_hostile_ones_are_errors() {
+        assert_eq!(parse_page_range("1-3, 5", 6), Ok(vec![0, 1, 2, 4]));
+        assert_eq!(parse_page_range("5,1-2,2", 6), Ok(vec![0, 1, 4]), "document order, no repeats");
+        assert_eq!(parse_page_range("4-", 6), Ok(vec![3, 4, 5]));
+        assert_eq!(parse_page_range("-2", 6), Ok(vec![0, 1]));
+        for bad in ["", " , ", "0", "7", "3-1", "a", "1-2-3", "99999999999999999999999", "-", "1..3", &"1,".repeat(400)] {
+            assert!(parse_page_range(bad, 6).is_err(), "`{bad}` is refused");
+        }
+        assert!(parse_page_range("1", 0).is_err());
+    }
+
+    #[test]
+    fn plans_apply_range_parity_copies_and_caps() {
+        let p = |v: Value| plan(&v, 6, (2, 3)).map(|p| p.pages);
+        assert_eq!(p(json!({})), Ok(vec![0, 1, 2, 3, 4, 5]));
+        assert_eq!(p(json!({"range": "current"})), Ok(vec![2]));
+        assert_eq!(p(json!({"range": "selection"})), Ok(vec![2, 3]));
+        assert_eq!(p(json!({"pages": "2-4", "copies": 2})), Ok(vec![1, 2, 3, 1, 2, 3]));
+        assert_eq!(p(json!({"pages": "2-3", "copies": 2, "collate": false})), Ok(vec![1, 1, 2, 2]));
+        assert_eq!(p(json!({"parity": "even"})), Ok(vec![1, 3, 5]));
+        assert!(p(json!({"range": "custom"})).is_err(), "custom needs pages");
+        assert!(p(json!({"range": "everything"})).is_err());
+        assert!(p(json!({"range": "current", "parity": "even"})).is_err(), "page 3 is odd: nothing left");
+        // Hostile copies are clamped; a job that would be too big is refused, not allocated.
+        assert_eq!(p(json!({"range": "current", "copies": 1e12})).map(|v| v.len()), Ok(MAX_COPIES as usize));
+        assert!(plan(&json!({"copies": 999}), 600, (0, 0)).is_err());
+        assert_eq!(p(json!({"copies": -5, "range": "current"})), Ok(vec![2]));
+    }
+
+    #[test]
+    fn print_pdf_writes_only_the_chosen_pages() {
+        let mut s = Session::new(crate::sample::sample_document());
+        let pages = s.export_layout().pages.len();
+        let (all, _) = s.print_pdf(&json!({})).unwrap();
+        let (one, plan) = s.print_pdf(&json!({"range": "current", "copies": 2})).unwrap();
+        assert!(all.starts_with(b"%PDF") && one.starts_with(b"%PDF"));
+        assert_eq!(plan.pages.len(), 2);
+        if pages > 2 {
+            assert!(one.len() < all.len());
+        }
+        assert!(s.print_pdf(&json!({"pages": "9999"})).is_err());
+        let r = s.run("file.printPdf", &json!({})).is_err();
+        assert!(r, "printPdf needs a path");
+    }
+}
diff --git a/crates/engine/src/ribbon.rs b/crates/engine/src/ribbon.rs
index 06099704e9..341e7e76a2 100644
--- a/crates/engine/src/ribbon.rs
+++ b/crates/engine/src/ribbon.rs
@@ -15,9 +15,11 @@ use crate::Registry;
 
 /// The ribbon's tabs in their default order. `File` opens Backstage: it is always first and
 /// isn't part of the customizable list.
-pub const TABS: [&str; 12] = ["File", "Home", "Insert", "Draw", "Design", "Layout", "References", "Mailings", "Review", "View", "Zotero", "Help"];
+pub const TABS: [&str; 13] =
+    ["File", "Home", "Insert", "Draw", "Design", "Layout", "References", "Mailings", "Review", "View", "Developer", "Zotero", "Help"];
 /// Tabs that come up with the selection; custom tabs can't take their names.
-pub const CONTEXTUAL_TABS: [&str; 5] = ["Table Design", "Table Layout", "Picture Format", "Shape Format", "Equation"];
+pub const CONTEXTUAL_TABS: [&str; 7] =
+    ["Table Design", "Table Layout", "Picture Format", "Shape Format", "Equation", "Chart Design", "SmartArt Design"];
 /// The Quick Access Toolbar's commands until the user changes them.
 pub const DEFAULT_QAT: [&str; 3] = ["file.save", "edit.undo", "edit.redo"];
 
diff --git a/crates/engine/src/session.rs b/crates/engine/src/session.rs
index 7825e25e91..85f07b6745 100644
--- a/crates/engine/src/session.rs
+++ b/crates/engine/src/session.rs
@@ -68,6 +68,15 @@ pub struct ViewState {
     /// The Clipboard pane (Home › Clipboard): items collected by Copy and Cut.
     #[serde(default)]
     pub clipboard_pane: bool,
+    /// SmartArt Design › Text Pane: the selected SmartArt graphic's items as an editable outline.
+    #[serde(default)]
+    pub smart_art_pane: bool,
+    /// The Accessibility pane (Review › Check Accessibility): the checker's findings.
+    #[serde(default)]
+    pub accessibility_pane: bool,
+    /// The Alt Text pane (Picture/Shape Format › Alt Text): the selected object's or table's alt text.
+    #[serde(default)]
+    pub alt_text_pane: bool,
     pub multi_page: bool,
     /// Zoom to fit: "pageWidth", "onePage", "multiplePages", or empty.
     pub fit: String,
@@ -86,6 +95,17 @@ pub struct ViewState {
     /// Show field codes instead of their results (`view.fieldCodes`, Alt+F9).
     #[serde(default)]
     pub field_codes: bool,
+    /// Print Layout › Hide White Space: pages run together, the top and bottom margins (with
+    /// headers and footers) between pages collapse to a thin line. On screen only; the layout
+    /// and page count are unchanged.
+    #[serde(default)]
+    pub hide_white_space: bool,
+    /// Outline view: collapsed headings, Show Level, first lines, text formatting.
+    #[serde(default)]
+    pub outline: crate::cmd::outline::OutlineState,
+    /// Developer › Design Mode: every content control shows its frame and title.
+    #[serde(default)]
+    pub design_mode: bool,
 }
 
 fn on() -> bool {
@@ -108,6 +128,9 @@ impl Default for ViewState {
             style_inspector: false,
             comments_pane: false,
             clipboard_pane: false,
+            smart_art_pane: false,
+            accessibility_pane: false,
+            alt_text_pane: false,
             multi_page: false,
             fit: String::new(),
             web_width: 800.0,
@@ -118,6 +141,9 @@ impl Default for ViewState {
             hide_ink: false,
             draw: Default::default(),
             field_codes: false,
+            hide_white_space: false,
+            outline: Default::default(),
+            design_mode: false,
         }
     }
 }
@@ -131,6 +157,14 @@ pub struct FindState {
     pub match_case: bool,
     pub whole_word: bool,
     pub regex: bool,
+    /// Word's "Use wildcards" (#543).
+    pub wildcards: bool,
+    /// Take Find what literally: no `^` codes (`special: false`).
+    pub literal: bool,
+    pub match_prefix: bool,
+    pub match_suffix: bool,
+    pub ignore_punct: bool,
+    pub ignore_space: bool,
     /// Matches from the last search: (start, end).
     #[serde(skip)]
     pub results: Vec<(Pos, Pos)>,
@@ -147,6 +181,8 @@ struct Undo {
     label: String,
     doc: Document,
     sel: Selection,
+    /// Formatting waiting at the caret (Bold with nothing selected), so Undo takes it back too.
+    pending: Option<CharProps>,
 }
 
 /// What [`Session::restore`] needs to take commands back exactly: the document, the selection,
@@ -211,6 +247,8 @@ pub struct Session {
     pub registry: Arc<Registry>,
     /// Author name for comments and tracked changes.
     pub author: String,
+    /// Initials for comments (File › Options › General); empty = the name's initials.
+    pub initials: String,
     /// Format painter: copied formatting waiting to be applied (and whether it stays on).
     pub painter: Option<(CharProps, wordcraft_doc::props::ParaProps, bool)>,
     /// Last message for the status bar / agents.
@@ -230,7 +268,9 @@ pub struct Session {
     /// mail merge, recover), never on an edit.
     document_id: u64,
     cache: LayoutCache,
-    layout: Option<(u64, f32, ViewMode, Arc<DocLayout>, bool)>,
+    /// (revision, web width, view, layout, proofing, outline, (deletions left out, body
+    /// deletions in balloons)).
+    layout: Option<(u64, f32, ViewMode, Arc<DocLayout>, bool, Option<wordcraft_layout::outline::OutlineView>, (bool, bool))>,
     /// Picture edits: edited media key → original media key (Reset Picture).
     pub originals: std::collections::HashMap<String, String>,
     /// Last mutating command (Repeat).
@@ -238,8 +278,6 @@ pub struct Session {
     /// Macro being recorded: (name, steps).
     pub recording: Option<(String, Vec<(String, Value)>)>,
     pub macros: std::collections::BTreeMap<String, Vec<(String, Value)>>,
-    pub autocorrect_on: bool,
-    pub autocorrect_user: Vec<(String, String)>,
     /// Saved versions: (label, date, document).
     pub versions: Vec<(String, String, Document)>,
     /// Quick Parts / AutoText entries.
@@ -300,6 +338,7 @@ pub struct MathEdit {
 }
 
 /// Editing preferences that persist between runs (the front end saves and restores them).
+/// File › Options sets most of them (`file.options`).
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(default, rename_all = "camelCase")]
 pub struct Prefs {
@@ -308,20 +347,78 @@ pub struct Prefs {
     /// Track Changes Options: what markup shows and how revisions are drawn (per user, as in
     /// Word).
     pub markup: wordcraft_layout::display::MarkupOptions,
+    /// File › Print / Export: Print Markup. PDFs, prints and page images show comments in
+    /// balloons beside each page and tracked changes as marked up; HTML, Markdown and text
+    /// copies end with the comments (`file.printMarkup`).
+    pub print_markup: bool,
+    /// Language › Detect language automatically (per user, as in Word).
+    pub detect_language: bool,
+    /// Typing over a selection replaces it; off, the typed text goes in front of it.
+    pub typing_replaces_selection: bool,
+    /// The Insert key switches overtype on and off.
+    pub insert_key_overtype: bool,
+    /// Overtype: typed characters replace the ones after the caret.
+    pub overtype: bool,
+    /// The unit rulers and dialogs show lengths in.
+    pub units: wordcraft_geom::Unit,
+    /// Formatting marks shown even while Show/Hide ¶ is off.
+    pub marks: wordcraft_layout::display::FormattingMarks,
+    /// Mark grammar errors as you type (with Check spelling as you type on).
+    pub mark_grammar: bool,
+    pub ignore_uppercase: bool,
+    pub ignore_numbers: bool,
+    pub ignore_internet: bool,
+    /// AutoCorrect Options: replacements, capitalization and AutoFormat As You Type (per user, as
+    /// in Word). A damaged saved value reads as the defaults.
+    #[serde(deserialize_with = "crate::cmd::tools::lenient_autocorrect")]
+    pub autocorrect: crate::cmd::tools::AutoCorrectPrefs,
 }
 
 impl Default for Prefs {
     fn default() -> Self {
-        Prefs { count_notes: true, markup: Default::default() }
+        Prefs {
+            count_notes: true,
+            markup: Default::default(),
+            print_markup: false,
+            typing_replaces_selection: true,
+            insert_key_overtype: false,
+            overtype: false,
+            units: Default::default(),
+            marks: Default::default(),
+            mark_grammar: true,
+            ignore_uppercase: true,
+            ignore_numbers: true,
+            ignore_internet: true,
+            detect_language: true,
+            autocorrect: Default::default(),
+        }
     }
 }
 
+impl Prefs {
+    /// What the spelling check skips.
+    pub fn spelling(&self) -> wordcraft_proof::Options {
+        wordcraft_proof::Options {
+            ignore_uppercase: self.ignore_uppercase,
+            ignore_numbers: self.ignore_numbers,
+            ignore_internet: self.ignore_internet,
+        }
+    }
+}
+
+/// The citation style a document records (References › Style), APA when it records none or
+/// one we don't know.
+fn doc_bib_style(doc: &Document) -> String {
+    doc.settings.bib_style.as_deref().and_then(crate::cmd::citations::find_style).map_or("APA", |st| st.name).to_string()
+}
+
 /// Maximum undo depth.
 const MAX_UNDO: usize = 500;
 
 impl Session {
     pub fn new(doc: Document) -> Self {
         let start = doc.start_of(StoryRef::Body);
+        let bib_style = doc_bib_style(&doc);
         Session {
             doc,
             sel: Selection::caret(start),
@@ -338,6 +435,7 @@ impl Session {
             page_hint: 0,
             registry: Arc::new(crate::cmd::registry()),
             author: "WordCraft User".into(),
+            initials: String::new(),
             painter: None,
             status: String::new(),
             history: Vec::new(),
@@ -353,12 +451,10 @@ impl Session {
             last_command: None,
             recording: None,
             macros: Default::default(),
-            autocorrect_on: true,
-            autocorrect_user: Vec::new(),
             versions: Vec::new(),
             building_blocks: Default::default(),
             autosave: true,
-            bib_style: "APA".into(),
+            bib_style,
             merge: Default::default(),
             ui_requests: Vec::new(),
             math: None,
@@ -441,33 +537,76 @@ impl Session {
         self.find.highlights.as_ref().map(|(_, v)| v.as_slice()).unwrap_or(&[])
     }
 
+    /// Whether the markup area beside the page can show balloons: markup shown in Print Layout
+    /// (not Read Mode or pages side by side), comments not listed in the Comments pane instead,
+    /// and Track Changes Options not set to show every revision inline.
+    pub fn balloons_shown(&self) -> bool {
+        let v = &self.view;
+        v.show_markup
+            && !v.comments_pane
+            && !v.read_mode
+            && !v.multi_page
+            && v.mode == ViewMode::Print
+            && self.prefs.markup.balloons != wordcraft_layout::display::BalloonMode::Inline
+    }
+
+    /// Show revisions in balloons, with the balloons on screen: tracked deletions in the body leave
+    /// the text for balloons in the markup area. Where no balloons can be shown they stay inline,
+    /// as in Word; so do deletions in headers, footers, notes and text boxes, which get no balloons.
+    pub fn revisions_in_balloons(&self) -> bool {
+        let m = &self.prefs.markup;
+        self.balloons_shown() && m.balloons == wordcraft_layout::display::BalloonMode::Revisions && m.insertions_deletions
+    }
+
+    /// Initials for new comments: the ones set in File › Options, else the user name's.
+    pub fn user_initials(&self) -> String {
+        let set = self.initials.trim();
+        if set.is_empty() { self.author.split_whitespace().filter_map(|w| w.chars().next()).collect() } else { set.to_string() }
+    }
+
     /// The current layout (recomputed when the document or view changed).
     pub fn layout(&mut self) -> Arc<DocLayout> {
         let ww = self.view.web_width;
-        if let Some((r, w, m, l, pf)) = &self.layout
+        // Deletions in balloons depend on the view (the Comments pane, Read Mode, side by side), so
+        // a view change that moves them in or out of the text lays it out again.
+        let hide_deleted = !self.view.show_markup || self.prefs.markup.hides_deletions();
+        let deleted = (hide_deleted, self.revisions_in_balloons());
+        let outline = (self.view.mode == ViewMode::Outline).then(|| self.view.outline.view());
+        if let Some((r, w, m, l, pf, o, hd)) = &self.layout
             && *r == self.rev
             && (*w == ww || self.view.mode == ViewMode::Print)
             && *m == self.view.mode
             && *pf == self.view.proofing
+            && *hd == deleted
+            && *o == outline
         {
             return l.clone();
         }
         let opts = LayoutOptions {
             view: self.view.mode,
             web_width: ww,
-            show_hidden: self.view.marks,
-            hide_deleted: !self.view.show_markup || self.prefs.markup.hides_deletions(),
+            show_hidden: self.view.marks || self.prefs.marks.hidden,
+            hide_deleted,
+            deletions_in_balloons: deleted.1,
             proofing: self.view.proofing,
+            comment_balloons: false,
             field_codes: self.view.field_codes,
+            outline: outline.clone(),
+            proof: wordcraft_layout::ProofOptions { grammar: self.prefs.mark_grammar, spelling: self.prefs.spelling() },
         };
         let l = Arc::new(wordcraft_layout::layout(&self.doc, &mut self.cache, &opts));
-        self.layout = Some((self.rev, ww, self.view.mode, l.clone(), self.view.proofing));
+        self.layout = Some((self.rev, ww, self.view.mode, l.clone(), self.view.proofing, outline, deleted));
         l
     }
     /// A layout for output (PDF, images, print): no proofing marks, print view.
     pub fn export_layout(&self) -> Arc<DocLayout> {
-        let opts =
-            LayoutOptions { view: ViewMode::Print, web_width: 0.0, show_hidden: false, hide_deleted: false, proofing: false, field_codes: false };
+        self.export_layout_with(false)
+    }
+
+    /// [`Session::export_layout`]; with `markup` (Print Markup) each page also has the markup
+    /// area with the comments in balloons.
+    pub fn export_layout_with(&self, markup: bool) -> Arc<DocLayout> {
+        let opts = LayoutOptions { view: ViewMode::Print, comment_balloons: markup && self.prefs.markup.comments, ..Default::default() };
         Arc::new(wordcraft_layout::layout(&self.doc, &mut LayoutCache::new(), &opts))
     }
 
@@ -501,7 +640,7 @@ impl Session {
             return;
         }
         self.typing_open = label == "Typing";
-        self.history.push(Arc::new(Undo { label: label.to_string(), doc: self.doc.clone(), sel: self.sel.clone() }));
+        self.history.push(Arc::new(Undo { label: label.to_string(), doc: self.doc.clone(), sel: self.sel.clone(), pending: self.pending.clone() }));
         if self.history.len() > MAX_UNDO {
             self.history.remove(0);
             self.undo_evicted += 1;
@@ -511,7 +650,7 @@ impl Session {
     /// Record `doc`/`sel` as their own undo step after the fact and close the typing group, so
     /// Undo right after an automatic change (AutoFormat, AutoCorrect) reverts only that change.
     pub fn push_undo(&mut self, label: &str, doc: Document, sel: Selection) {
-        self.history.push(Arc::new(Undo { label: label.to_string(), doc, sel }));
+        self.history.push(Arc::new(Undo { label: label.to_string(), doc, sel, pending: self.pending.clone() }));
         if self.history.len() > MAX_UNDO {
             self.history.remove(0);
             self.undo_evicted += 1;
@@ -562,15 +701,30 @@ impl Session {
     pub fn undo(&mut self) -> bool {
         self.typing_open = false;
         let Some(u) = self.history.pop().map(Arc::unwrap_or_clone) else { return false };
-        let cur = Undo { label: u.label.clone(), doc: std::mem::replace(&mut self.doc, u.doc), sel: std::mem::replace(&mut self.sel, u.sel) };
+        let cur = Undo {
+            label: u.label.clone(),
+            doc: std::mem::replace(&mut self.doc, u.doc),
+            sel: std::mem::replace(&mut self.sel, u.sel),
+            pending: std::mem::replace(&mut self.pending, u.pending),
+        };
         self.redo.push(Arc::new(cur));
         self.touch();
         true
     }
+    /// Would Undo (or Redo) take the document's protection away? Only Stop Protection lifts it.
+    pub fn step_lifts_protection(&self, redo: bool) -> bool {
+        let next = if redo { self.redo.last() } else { self.history.last() };
+        next.is_some_and(|u| crate::cmd::protect::protection_lifted(&self.doc, &u.doc))
+    }
     pub fn redo(&mut self) -> bool {
         self.typing_open = false;
         let Some(u) = self.redo.pop().map(Arc::unwrap_or_clone) else { return false };
-        let cur = Undo { label: u.label.clone(), doc: std::mem::replace(&mut self.doc, u.doc), sel: std::mem::replace(&mut self.sel, u.sel) };
+        let cur = Undo {
+            label: u.label.clone(),
+            doc: std::mem::replace(&mut self.doc, u.doc),
+            sel: std::mem::replace(&mut self.sel, u.sel),
+            pending: std::mem::replace(&mut self.pending, u.pending),
+        };
         self.history.push(Arc::new(cur));
         self.touch();
         true
@@ -585,6 +739,7 @@ impl Session {
     /// Replace the document (open/new).
     pub fn set_document(&mut self, doc: Document) {
         self.document_id = self.document_id.wrapping_add(1);
+        self.bib_style = doc_bib_style(&doc);
         self.doc = doc;
         self.doc.ensure_nonempty();
         self.password = None;
@@ -595,6 +750,7 @@ impl Session {
         self.column_mode = false;
         self.edit_marks.clear();
         self.go_back_step = 0;
+        self.view.outline.collapsed.clear();
         self.reset_history();
         self.touch();
         self.dirty = false;
@@ -635,6 +791,7 @@ impl Session {
             page_hint: _,
             registry: _,
             author: _,
+            initials: _,
             painter: _,
             status: _,
             history,
@@ -649,8 +806,6 @@ impl Session {
             last_command: _,
             recording: _,
             macros: _,
-            autocorrect_on: _,
-            autocorrect_user: _,
             versions: _,
             building_blocks: _,
             autosave: _,
@@ -745,27 +900,27 @@ impl Session {
         if let Some(why) = (spec.enabled)(self) {
             return Err(CmdError::Disabled(format!("{id}: {why}")));
         }
-        // Restrict Editing.
-        if spec.mutates
-            && let Some(mode) = self.doc.settings.protection.clone()
-        {
-            let allowed = id.starts_with("review.restrict") || id.starts_with("file.") || id == "edit.undo" || id == "edit.redo";
-            let comment_ok = id.starts_with("review.") && (id.contains("Comment") || id == "review.reply");
-            match mode.as_str() {
-                "readOnly" | "forms" if !allowed => return Err(CmdError::Disabled(format!("{id}: the document is protected (read only)"))),
-                "comments" if !allowed && !comment_ok => return Err(CmdError::Disabled(format!("{id}: only comments are allowed in this document"))),
-                "trackedChanges" => self.doc.settings.track_changes = true,
-                _ => {}
-            }
+        // Restrict Editing: refused outright, or allowed as long as it only edits the exceptions.
+        let guard = if spec.mutates { crate::cmd::protect::check_before(self, id, params)? } else { false };
+        if spec.mutates && self.doc.settings.protection.as_deref() == Some("trackedChanges") {
+            self.doc.settings.track_changes = true;
         }
         // Macro recording and Repeat.
         let record = !matches!(id, "tools.recordMacro" | "tools.macros" | "edit.undo" | "edit.redo" | "edit.repeat")
             && (spec.mutates || id.starts_with("caret.") || id.starts_with("select."));
+        // A password never lands in a recorded macro or Repeat.
+        let kept = || {
+            let mut p = params.clone();
+            if let Some(m) = p.as_object_mut() {
+                m.remove("password");
+            }
+            p
+        };
         if record && let Some((_, steps)) = self.recording.as_mut() {
-            steps.push((id.to_string(), params.clone()));
+            steps.push((id.to_string(), kept()));
         }
         if spec.mutates && !matches!(id, "edit.undo" | "edit.redo" | "edit.repeat") {
-            self.last_command = Some((id.to_string(), params.clone()));
+            self.last_command = Some((id.to_string(), kept()));
         }
         // Typing, caret movement and selection outside the equation commands leave the equation.
         if self.math.is_some()
@@ -812,13 +967,21 @@ impl Session {
         let run = spec.run;
         let mutates = spec.mutates;
         let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| crate::cmd::column::dispatch(self, id, mutates, run, params)));
-        let result = match result {
+        let mut result = match result {
             Ok(r) => r,
             Err(p) => {
                 let msg = p.downcast_ref::<&str>().map(|s| s.to_string()).or_else(|| p.downcast_ref::<String>().cloned()).unwrap_or_default();
                 Err(CmdError::Failed(format!("{id} panicked: {msg}")))
             }
         };
+        // Restrict Editing: outside the exceptions nothing may change.
+        if result.is_ok()
+            && guard
+            && let Some((before, ..)) = &before_doc
+            && !crate::cmd::protect::outside_unchanged(before, &self.doc, &self.author)
+        {
+            result = Err(CmdError::Disabled(format!("{id}: only the editable regions of this protected document can change")));
+        }
         match &result {
             Ok(_) => {
                 if spec.mutates {
@@ -829,11 +992,22 @@ impl Session {
                     self.touch();
                     self.doc.ensure_nonempty();
                     self.doc.prune_text_boxes();
+                    // Glued connectors follow the shapes they join.
+                    if crate::cmd::connectors::reroutes_after(id) && crate::cmd::connectors::reroute(self) {
+                        self.touch();
+                    }
                 }
                 self.clamp_selection();
+                // A selection command that moves the insertion point ends the typing group, like
+                // caret movement: typing, Select, typing are two undo steps (#419).
+                if !spec.mutates && self.sel != sel_before {
+                    self.typing_open = false;
+                }
                 if spec.mutates && !matches!(id, "edit.undo" | "edit.redo") {
                     self.note_edit();
                 }
+                // Outline view: collapsed headings follow edits; the caret stays where it shows.
+                crate::cmd::outline::after_command(self, &sel_before);
                 // Extra selected objects last until something else is edited or selected.
                 if !matches!(id, "select.addObject" | "arrange.ungroup") && (spec.mutates || self.sel != sel_before) {
                     self.also_selected.clear();
diff --git a/crates/engine/src/speech.rs b/crates/engine/src/speech.rs
index e97cce9946..9530c81975 100644
--- a/crates/engine/src/speech.rs
+++ b/crates/engine/src/speech.rs
@@ -496,6 +496,15 @@ fn worker(shared: &(Mutex<Shared>, Condvar), backend: Backend) {
     }
 }
 
+/// Windows PowerShell by its full path, `<SystemRoot>\System32\WindowsPowerShell\v1.0\powershell.exe`
+/// (`C:\Windows` when `SystemRoot` is unset), rather than whichever `powershell` the program search
+/// finds first.
+#[cfg(any(target_os = "windows", test))]
+fn windows_powershell(system_root: Option<std::ffi::OsString>) -> std::path::PathBuf {
+    let root = system_root.filter(|r| !r.is_empty()).unwrap_or_else(|| "C:\\Windows".into());
+    std::path::Path::new(&root).join("System32").join("WindowsPowerShell").join("v1.0").join("powershell.exe")
+}
+
 /// Speak one sentence with the system's speech program, stopping early when `changed()`.
 #[cfg(not(target_arch = "wasm32"))]
 fn speak(text: &str, rate: f32, changed: &dyn Fn() -> bool) -> Spoken {
@@ -517,7 +526,7 @@ fn speak(text: &str, rate: f32, changed: &dyn Fn() -> bool) -> Spoken {
         let script = format!(
             "Add-Type -AssemblyName System.Speech; $s = New-Object System.Speech.Synthesis.SpeechSynthesizer; $s.Rate = {r}; $s.Speak([Console]::In.ReadToEnd())"
         );
-        let mut c = Command::new("powershell");
+        let mut c = Command::new(windows_powershell(std::env::var_os("SystemRoot")));
         c.args(["-NoProfile", "-NonInteractive", "-Command", &script]);
         tries.push(c);
     }
@@ -571,6 +580,18 @@ mod tests {
         v.iter().map(|u| u.text.as_str()).collect()
     }
 
+    #[test]
+    fn powershell_is_launched_from_the_system_folder() {
+        let tail = std::path::Path::new("System32").join("WindowsPowerShell").join("v1.0").join("powershell.exe");
+        let p = windows_powershell(Some("D:\\Win".into()));
+        assert!(p.starts_with("D:\\Win") && p.ends_with(&tail), "{}", p.display());
+        // No SystemRoot, or an empty one: the default Windows folder.
+        for root in [None, Some("".into())] {
+            let p = windows_powershell(root);
+            assert!(p.starts_with("C:\\Windows") && p.ends_with(&tail), "{}", p.display());
+        }
+    }
+
     #[test]
     fn splits_sentences_but_not_abbreviations() {
         let t = "Smith et al. found 3.5 times more (see Fig. 2). J. Smith agreed! Did they? Yes… Pick one, e.g. this one.";
diff --git a/crates/engine/src/tests.rs b/crates/engine/src/tests.rs
index 2e9789a289..6b6b7fe560 100644
--- a/crates/engine/src/tests.rs
+++ b/crates/engine/src/tests.rs
@@ -312,8 +312,9 @@ fn failed_command_restores_history_changed_by_nested_commands() {
     // outer and nested checkpoints each evict the oldest step.
     fn timeline(s: &mut Session) -> Vec<(Vec<String>, wordcraft_doc::Document)> {
         let mut out = Vec::new();
+        // Straight through the history (the commands won't undo past Restrict Editing).
         while s.can_redo() {
-            run(s, "edit.redo", json!({}));
+            s.redo();
         }
         loop {
             // Comments are stamped with the time to the second, and the two sessions compared
@@ -324,7 +325,7 @@ fn failed_command_restores_history_changed_by_nested_commands() {
             if !s.can_undo() {
                 return out;
             }
-            run(s, "edit.undo", json!({}));
+            s.undo();
         }
     }
     let kept = {
@@ -496,6 +497,75 @@ fn find_replace() {
     assert_eq!(r["count"], 4);
 }
 
+#[test]
+fn find_replace_special_codes() {
+    // ^p finds paragraph marks across paragraphs; Replace All with ^p splits paragraphs and is one undo step.
+    let mut s = s();
+    run(&mut s, "document.setText", json!({"text": "one\ntwo\nthree"}));
+    let paras = |s: &Session| s.doc.para_paths(StoryRef::Body).len();
+    assert_eq!(run(&mut s, "edit.find", json!({"text": "^p"}))["count"], 2);
+    assert_eq!(run(&mut s, "edit.replaceAll", json!({"text": "o^pt", "with": "O+T"}))["replaced"], 1);
+    assert_eq!((text(&s).as_str(), paras(&s)), ("one\ntwO+Three", 2));
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!((text(&s).as_str(), paras(&s)), ("one\ntwo\nthree", 3));
+    run(&mut s, "document.setText", json!({"text": "a, b, c"}));
+    assert_eq!(run(&mut s, "edit.replaceAll", json!({"text": ", ", "with": "^p"}))["replaced"], 2);
+    assert_eq!((text(&s).as_str(), paras(&s)), ("a\nb\nc", 3));
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!((text(&s).as_str(), paras(&s)), ("a, b, c", 1));
+    // ^t, ^# and ^& (the found text), ^^ is a caret.
+    run(&mut s, "document.setText", json!({"text": "x\ty 12 a^b"}));
+    assert_eq!(run(&mut s, "edit.replaceAll", json!({"text": "^t", "with": " "}))["replaced"], 1);
+    assert_eq!(run(&mut s, "edit.replaceAll", json!({"text": "^#", "with": "<^&>"}))["replaced"], 2);
+    assert_eq!(run(&mut s, "edit.replaceAll", json!({"text": "^^", "with": "-"}))["replaced"], 1);
+    assert_eq!(text(&s), "x y <1><2> a-b");
+    // `special: false` reads the text literally.
+    assert_eq!(run(&mut s, "edit.find", json!({"text": "^#", "special": false}))["count"], 0);
+}
+
+#[test]
+fn find_replace_wildcards() {
+    let mut s = s();
+    // Groups and back-references swap words; Use wildcards matches case.
+    run(&mut s, "document.setText", json!({"text": "Smith, John and Doe, Jane; smith, x"}));
+    let r = run(&mut s, "edit.replaceAll", json!({"text": "([A-Z][a-z]@), ([A-Z][a-z]@)", "with": "\\2 \\1", "wildcards": true}));
+    assert_eq!(r["replaced"], 2);
+    assert_eq!(text(&s), "John Smith and Jane Doe; smith, x");
+    // < and > anchor to word starts and ends; * is the shortest run; {n} counts.
+    run(&mut s, "document.setText", json!({"text": "cat concat cats scatter"}));
+    assert_eq!(run(&mut s, "edit.find", json!({"text": "<cat", "wildcards": true}))["count"], 2);
+    assert_eq!(run(&mut s, "edit.find", json!({"text": "cat>", "wildcards": true}))["count"], 2);
+    assert_eq!(run(&mut s, "edit.find", json!({"text": "<c*t>", "wildcards": true}))["count"], 2);
+    assert_eq!(run(&mut s, "edit.find", json!({"text": "t{2}", "wildcards": true}))["count"], 1);
+    assert_eq!(run(&mut s, "edit.find", json!({"text": "[!c]at", "wildcards": true}))["count"], 0);
+    assert_eq!(run(&mut s, "edit.find", json!({"text": "[!s ]cat", "wildcards": true}))["count"], 1);
+    // Options of the normal search: prefix, suffix, ignore punctuation.
+    assert_eq!(run(&mut s, "edit.find", json!({"text": "cat", "wildcards": false, "matchPrefix": true}))["count"], 2);
+    assert_eq!(run(&mut s, "edit.find", json!({"text": "cat", "matchPrefix": false, "matchSuffix": true}))["count"], 2);
+    run(&mut s, "document.setText", json!({"text": "e.g. eg"}));
+    assert_eq!(run(&mut s, "edit.find", json!({"text": "eg", "matchSuffix": false, "ignorePunct": true}))["count"], 2);
+}
+
+#[test]
+fn hostile_find_patterns_are_bounded() {
+    let mut s = s();
+    run(&mut s, "document.setText", json!({"text": &"a".repeat(5000)}));
+    // Patterns that backtrack catastrophically elsewhere finish quickly (linear-time engine).
+    let t = std::time::Instant::now();
+    for q in ["(a@)@b", "(*)@b", "(a{1,1000}){1,1000}", "(((((a*)*)*)*)*)b"] {
+        let _ = s.run("edit.find", &json!({"text": q, "wildcards": true}));
+    }
+    assert!(t.elapsed().as_secs() < 20);
+    // Bad and oversized patterns are errors, not crashes.
+    for q in ["[z-a]", "a{5", "(ab", "\\1", "x{2000}", "[", "@"] {
+        assert!(s.run("edit.find", &json!({"text": q, "wildcards": true})).is_err(), "{q}");
+    }
+    assert!(s.run("edit.find", &json!({"text": "x".repeat(2000), "wildcards": false})).is_err());
+    for q in ["^", "^p^", "^u", "^99999999", "^0", "a^"] {
+        let _ = s.run("edit.replaceAll", &json!({"text": q, "with": "^&^c\\9^p^", "wildcards": false}));
+    }
+}
+
 #[test]
 fn replace_under_track_changes_skips_deleted_text() {
     // Replace marks the match deleted and leaves it in the text; the next
@@ -580,6 +650,30 @@ fn find_reads_the_text_around_tracked_deletions() {
     assert_eq!(r["remaining"], 1);
 }
 
+#[test]
+fn find_next_with_options_visits_every_match() {
+    // The Find dialog sends its options with each Find Next (#468): every click is one step.
+    let opts = json!({"text": "cat", "with": "", "matchCase": false, "wholeWord": false, "regex": false});
+    let starts = |text: &str, clicks: usize, cmd: &str| {
+        let mut s = s();
+        run(&mut s, "document.setText", json!({"text": text}));
+        run(&mut s, "caret.docStart", json!({}));
+        (0..clicks).map(|_| run(&mut s, cmd, opts.clone())["index"].as_u64().unwrap()).collect::<Vec<_>>()
+    };
+    assert_eq!(starts("cat cat cat cat", 5, "edit.findNext"), [0, 1, 2, 3, 0]);
+    assert_eq!(starts("cat cat", 3, "edit.findNext"), [0, 1, 0]);
+    assert_eq!(starts("cat cat cat", 4, "edit.findPrevious"), [2, 1, 0, 2]);
+
+    // A new query takes effect at once, without a separate `edit.find`.
+    let mut s = s();
+    run(&mut s, "document.setText", json!({"text": "cat dog cat dog"}));
+    run(&mut s, "caret.docStart", json!({}));
+    assert_eq!(run(&mut s, "edit.findNext", opts.clone())["index"], 0);
+    let r = run(&mut s, "edit.findNext", json!({"text": "dog"}));
+    assert_eq!((r["index"].clone(), r["count"].clone()), (json!(0), json!(2)));
+    assert_eq!(s.sel.ordered().0.off, 4);
+}
+
 #[test]
 fn clipboard_round_trip() {
     let mut s = s();
@@ -2048,6 +2142,49 @@ fn styles_apply_multi_paragraph_selection() {
     }
 }
 
+/// #555: Update Heading 2 to Match Selection (the styles pane's context menu) makes Heading 2
+/// look like the selected text — its paragraph style and direct formatting — so every Heading 2
+/// paragraph changes; the selected paragraph takes Heading 2, and it is one undo step.
+#[test]
+fn update_heading_to_match_selection_takes_the_selections_formatting() {
+    use wordcraft_doc::{Align, CharProps, ParaProps, Rgb, TextColor};
+    let mut s = s();
+    run(&mut s, "text.insert", json!({"text": "Heading text"}));
+    run(&mut s, "styles.apply", json!({"style": "Heading 2"}));
+    run(&mut s, "text.newParagraph", json!({}));
+    run(&mut s, "text.insert", json!({"text": "Body text"}));
+    run(&mut s, "styles.apply", json!({"style": "Normal"}));
+    run(&mut s, "select.text", json!({"text": "Body text"}));
+    run(&mut s, "format.size", json!({"size": 20}));
+    run(&mut s, "format.italic", json!({}));
+    run(&mut s, "format.color", json!({"color": "C00000"}));
+    run(&mut s, "para.alignCenter", json!({}));
+    let normal = s.doc.styles.resolve_char(Some("Normal"), &CharProps::default());
+    let before = s.undo_depth();
+
+    run(&mut s, "styles.updateToMatch", json!({"style": "Heading2"}));
+
+    let h2 = ParaProps { style: Some("Heading2".into()), ..Default::default() };
+    let c = s.doc.styles.resolve_char(Some("Heading2"), &CharProps::default());
+    assert_eq!(c.size, 20.0);
+    assert!(c.italic);
+    assert_eq!(c.color, TextColor::Rgb(Rgb(0xC0, 0, 0)));
+    assert_eq!(c.font, normal.font, "the heading font gives way to the selection's");
+    let p = s.doc.styles.resolve_para(&h2);
+    assert_eq!(p.align, Align::Center);
+    assert_eq!(p.outline_level, Some(1), "Heading 2 stays a level-2 heading");
+    // The selected paragraph now carries Heading 2, its direct formatting absorbed by the style.
+    assert_eq!(para_style(&s, 1).as_deref(), Some("Heading2"));
+    let body = s.doc.para_at(&Pos::body(1, 0)).unwrap();
+    assert!(body.props_of_char(0).formatting().is_empty(), "{:?}", body.props_of_char(0));
+    assert_eq!(body.props.align, None);
+    assert_eq!(s.undo_depth(), before + 1, "one undo step");
+
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(s.doc.styles.resolve_char(Some("Heading2"), &CharProps::default()).size, 16.0);
+    assert_eq!(para_style(&s, 1).as_deref(), Some("Normal"));
+}
+
 #[test]
 fn styles_apply_rejected_on_protected_document() {
     let mut s = s();
@@ -2083,7 +2220,7 @@ fn column_selection_copies_the_block() {
     // A caret move drops the block; pasting the copy gives three paragraphs.
     run(&mut s, "caret.docEnd", json!({}));
     assert!(s.column_segments().is_none());
-    s.autocorrect_on = false;
+    s.prefs.autocorrect.enabled = false;
     run(&mut s, "text.newParagraph", json!({}));
     run(&mut s, "edit.paste", json!({}));
     assert_eq!(text(&s), "abcdef\nabcdef\nabcdef\ncd\ncd\ncd");
@@ -2453,6 +2590,107 @@ fn charts_and_diagrams_can_be_selected_and_deleted_but_not_moved() {
     assert!(s.doc.para_at(&Pos::body(0, 0)).is_some_and(|p| p.objects.is_empty()), "the chart is deleted");
 }
 
+/// The chart model of the first object in the body's first paragraph.
+fn first_chart(doc: &wordcraft_doc::Document) -> Option<wordcraft_doc::chart::ChartSpec> {
+    use wordcraft_doc::para::InlineObject;
+    let p = doc.para_at(&Pos::body(0, 0))?;
+    p.object_offsets().into_iter().find_map(|off| match p.object_at(off) {
+        Some(InlineObject::Graphic { graphic, .. }) => graphic.chart.as_deref().cloned(),
+        _ => None,
+    })
+}
+
+#[test]
+fn inserted_chart_is_saved_and_reopened_with_its_data() {
+    let mut s = s();
+    let data =
+        json!({"categories": ["Jan", "Feb", "Mar"], "series": [{"name": "Rain", "values": [12.5, null, 3]}, {"name": "Sun", "values": [4, 5, 6]}]});
+    let r = run(&mut s, "insert.chart", json!({"type": "line", "data": data, "title": "Weather", "legend": "right"}));
+    assert_eq!(r["chart"]["type"], "line");
+    let spec = first_chart(&s.doc).expect("a chart with a model");
+    assert_eq!(spec.series[0].values, vec![Some(12.5), None, Some(3.0)]);
+    assert!(crate::cmd::chart::selected_chart(&s).is_some(), "the new chart is selected");
+    let bytes = wordcraft_docx::write(&s.doc).unwrap();
+    assert!(bytes.windows(22).any(|w| w == b"word/charts/chart1.xml"), "a chart part is written");
+    let back = wordcraft_docx::read(&bytes).unwrap();
+    assert_eq!(first_chart(&back), Some(spec), "the chart reads back as the same editable chart");
+    // Sample data when none is given.
+    let mut s2 = self::s();
+    run(&mut s2, "insert.chart", json!({"type": "pie"}));
+    assert!(first_chart(&s2.doc).is_some_and(|c| c.kind == wordcraft_doc::chart::ChartType::Pie && !c.series.is_empty()));
+    // No params: the picker, nothing inserted.
+    let mut s3 = self::s();
+    run(&mut s3, "insert.chart", json!({}));
+    assert!(s3.ui_requests.iter().any(|r| r["open"] == "insertChart"));
+    assert!(first_chart(&s3.doc).is_none());
+}
+
+#[test]
+fn chart_edits_are_one_undo_step_each() {
+    use wordcraft_doc::chart::{ChartType, LegendPos};
+    let mut s = s();
+    run(&mut s, "insert.chart", json!({"type": "column"}));
+    let before = first_chart(&s.doc).unwrap();
+    run(&mut s, "chart.editData", json!({"data": {"categories": ["A", "B"], "series": [{"name": "X", "values": [1, 2]}]}}));
+    run(&mut s, "chart.type", json!({"type": "barStacked"}));
+    run(&mut s, "chart.title", json!({"text": "Totals"}));
+    run(&mut s, "chart.legend", json!({"pos": "none"}));
+    run(&mut s, "chart.dataLabels", json!({"on": true}));
+    let c = first_chart(&s.doc).unwrap();
+    assert_eq!((c.kind, c.title.as_deref(), c.legend, c.data_labels), (ChartType::BarStacked, Some("Totals"), None, true));
+    assert_eq!((c.categories.len(), c.series.len()), (2, 1));
+    let steps: [&dyn Fn(&wordcraft_doc::chart::ChartSpec) -> bool; 5] = [
+        &|c| !c.data_labels,
+        &|c| c.legend == Some(LegendPos::Bottom),
+        &|c| c.title.is_none(),
+        &|c| c.kind == ChartType::Column && c.series.len() == 1,
+        &|c| *c == before,
+    ];
+    for (k, check) in steps.iter().enumerate() {
+        run(&mut s, "edit.undo", json!({}));
+        assert!(check(&first_chart(&s.doc).unwrap()), "undo step {k}");
+    }
+    // Resizing draws the chart again at its new size.
+    run(&mut s, "edit.redo", json!({}));
+    run(&mut s, "picture.size", json!({"width": 300, "height": 150, "lockAspect": false}));
+    let p = s.doc.para_at(&Pos::body(0, 0)).unwrap();
+    let Some(wordcraft_doc::para::InlineObject::Graphic { graphic, w, .. }) = p.object_offsets().into_iter().find_map(|o| p.object_at(o)) else {
+        panic!()
+    };
+    assert_eq!((*w, graphic.w, graphic.h), (300.0, 300.0, 150.0));
+}
+
+#[test]
+fn hostile_chart_data_is_capped() {
+    use wordcraft_doc::chart::{MAX_CELLS, MAX_POINTS, MAX_SERIES, MAX_TEXT};
+    let mut s = s();
+    let values: Vec<serde_json::Value> = (0..5000).map(|i| if i % 2 == 0 { json!("NaN") } else { json!(1e308) }).collect();
+    let series: Vec<serde_json::Value> = (0..300).map(|i| json!({"name": "n".repeat(10_000), "values": values, "x": i})).collect();
+    let cats: Vec<serde_json::Value> = (0..6000).map(|i| json!(i)).collect();
+    run(
+        &mut s,
+        "insert.chart",
+        json!({"type": "scatter", "data": {"categories": cats, "series": series}, "title": "\u{0}".repeat(9999), "width": 1e30}),
+    );
+    let c = first_chart(&s.doc).unwrap();
+    assert!(c.series.len() <= MAX_SERIES && c.points() <= MAX_POINTS && c.series.len() * c.points() <= MAX_CELLS);
+    assert!(c.series.iter().all(|x| x.name.chars().count() <= MAX_TEXT && x.values.len() == c.points()));
+    assert!(c.series[0].values.iter().all(|v| v.is_none_or(f64::is_finite)));
+    let _ = s.layout();
+    let back = wordcraft_docx::read(&wordcraft_docx::write(&s.doc).unwrap()).unwrap();
+    assert_eq!(first_chart(&back), Some(c));
+    for bad in [json!({"type": "radar"}), json!({"data": {"series": 5}}), json!({"data": {"series": []}})] {
+        assert!(s.run("insert.chart", &bad).is_err(), "{bad}");
+    }
+    // A chart without a model (from another program) is shown, not edited.
+    let mut s = self::s();
+    let foreign =
+        wordcraft_doc::para::InlineObject::Graphic { w: 200.0, h: 100.0, alt: String::new(), float: Default::default(), graphic: Default::default() };
+    s.doc.insert_object(&Pos::body(0, 0), foreign, &Default::default()).unwrap();
+    run(&mut s, "select.range", json!({"anchor": Pos::body(0, 0), "focus": Pos::body(0, wordcraft_doc::para::OBJ.len_utf8())}));
+    assert!(s.run("chart.type", &json!({"type": "pie"})).is_err());
+}
+
 #[test]
 fn accessibility_reports_a_chart_without_alt_text() {
     use std::sync::Arc;
@@ -2740,6 +2978,19 @@ fn style_visibility_round_trips_through_docx() {
     assert!(s.doc.styles.get("Heading4").is_some_and(|h| !h.quick), "undoable");
 }
 
+/// #548: `.xml` saves a Word XML Document (Flat OPC) and opens it again; other XML is refused.
+#[test]
+fn word_xml_saves_and_opens_through_io() {
+    let mut s = s();
+    run(&mut s, "text.insert", json!({"text": "Kept in one XML file"}));
+    let bytes = crate::io::save_bytes("notes.xml", &s.doc).unwrap();
+    assert_eq!(wordcraft_docx::sniff_xml(&bytes), wordcraft_docx::XmlKind::FlatOpc);
+    let doc = crate::io::open_bytes("notes.XML", &bytes).unwrap();
+    assert_eq!(doc.body, crate::io::open_bytes("n.docx", &crate::io::save_bytes("n.docx", &s.doc).unwrap()).unwrap().body);
+    let err = crate::io::open_bytes("feed.xml", b"<rss><channel/></rss>").unwrap_err();
+    assert!(err.contains("not a Word XML document"), "{err}");
+}
+
 /// #146: the first/last column, total row and banded column regions apply in layout (later
 /// regions win: the total row's fill beats the first column's) and round-trip through .docx.
 #[test]
@@ -2845,6 +3096,71 @@ fn deleting_the_last_cell_column_never_leaves_a_table_without_rows() {
     assert!(s.doc.body.iter().any(|b| b.as_table().is_some_and(|t| !t.rows.is_empty())));
 }
 
+#[test]
+fn center_after_select_paragraph_leaves_the_next_paragraph_alone() {
+    // #418: Select Paragraph ends at the next paragraph's start; that paragraph isn't selected.
+    use wordcraft_doc::Align;
+    let align = |s: &Session, i: usize| s.doc.para_at(&Pos::body(i, 0)).and_then(|p| p.props.align);
+    let mut s = s();
+    run(&mut s, "text.insert", json!({"text": "Alpha\rBeta", "raw": true}));
+    run(&mut s, "caret.set", json!({"pos": {"block": 0, "off": 2}}));
+    run(&mut s, "select.paragraph", json!({}));
+    assert_eq!(s.selected_text(), "Alpha\n");
+    run(&mut s, "para.alignCenter", json!({}));
+    assert_eq!((align(&s, 0), align(&s, 1)), (Some(Align::Center), None));
+    // Reversed, too; a range into Beta centres both; a caret at Beta's start centres Beta.
+    for (a, b, want) in [((1, 0), (0, 0), (Some(Align::Center), None)), ((0, 0), (1, 1), (Some(Align::Center), Some(Align::Center)))] {
+        let mut s = crate::Session::new(wordcraft_doc::Document::new());
+        run(&mut s, "text.insert", json!({"text": "Alpha\rBeta", "raw": true}));
+        run(&mut s, "caret.set", json!({"pos": {"block": a.0, "off": a.1}}));
+        run(&mut s, "caret.set", json!({"pos": {"block": b.0, "off": b.1}, "extend": true}));
+        run(&mut s, "para.align", json!({"value": "center"}));
+        assert_eq!((align(&s, 0), align(&s, 1)), want, "{a:?}..{b:?}");
+    }
+    let mut s = crate::Session::new(wordcraft_doc::Document::new());
+    run(&mut s, "text.insert", json!({"text": "Alpha\rBeta", "raw": true}));
+    run(&mut s, "caret.set", json!({"pos": {"block": 1, "off": 0}}));
+    run(&mut s, "para.alignCenter", json!({}));
+    assert_eq!((align(&s, 0), align(&s, 1)), (None, Some(Align::Center)));
+}
+
+#[test]
+fn change_case_keeps_the_selection_when_lengths_change() {
+    // #420: İ lowers to i + U+0307 (one byte more); the selection still covers the result.
+    let mut s = s();
+    run(&mut s, "text.insert", json!({"text": "aİxZ", "raw": true}));
+    run(&mut s, "select.text", json!({"text": "İx"}));
+    run(&mut s, "format.changeCase", json!({"mode": "lower"}));
+    assert_eq!(text(&s), "ai\u{307}xZ");
+    assert_eq!(s.selected_text(), "i\u{307}x");
+    // ı uppers to I (one byte less); the trailing Z stays out of the selection.
+    let mut s = crate::Session::new(wordcraft_doc::Document::new());
+    run(&mut s, "text.insert", json!({"text": "ıxZ", "raw": true}));
+    run(&mut s, "select.text", json!({"text": "ıx"}));
+    run(&mut s, "format.changeCase", json!({"mode": "upper"}));
+    assert_eq!(text(&s), "IXZ");
+    assert_eq!(s.selected_text(), "IX");
+}
+
+#[test]
+fn change_case_keeps_each_runs_formatting_when_lengths_change() {
+    // #421: lowercasing a plain İ and a bold x keeps x bold (and the i̇ plain).
+    let mut s = s();
+    run(&mut s, "text.insert", json!({"text": "İx", "raw": true}));
+    run(&mut s, "select.text", json!({"text": "x"}));
+    run(&mut s, "format.bold", json!({"value": true}));
+    run(&mut s, "select.all", json!({}));
+    run(&mut s, "format.changeCase", json!({"mode": "lower"}));
+    let p = s.doc.para_at(&Pos::body(0, 0)).unwrap();
+    assert_eq!(p.text, "i\u{307}x");
+    assert_ne!(p.props_of_char(0).bold, Some(true));
+    assert_ne!(p.props_of_char(1).bold, Some(true));
+    assert_eq!(p.props_of_char(3).bold, Some(true));
+    // Typing over the converted selection replaces all of it.
+    run(&mut s, "text.insert", json!({"text": "Q", "raw": true}));
+    assert_eq!(text(&s), "Q");
+}
+
 #[test]
 fn document_grid_sets_lines_and_characters_in_one_undo_step() {
     // #391: Layout › Page Setup › Document Grid.
@@ -2902,6 +3218,191 @@ fn insert_icon_places_a_picture_of_the_requested_size_that_saves_and_recolours()
     assert!(s.run("picture.iconColor", &json!({})).is_err());
 }
 
+/// Print Markup (#589): `file.printMarkup` or a command's `markup` puts the comments into PDFs
+/// (balloons beside the scaled page) and at the end of HTML, Markdown and text copies.
+#[test]
+fn print_markup_exports_comments() {
+    let mut s = Session::new(wordcraft_doc::Document::from_text("The quarterly figures look strong."));
+    s.author = "Ada Reviewer".into();
+    s.run("select.text", &json!({"text": "figures"})).unwrap();
+    let id = s.run("review.newComment", &json!({"text": "Check the totals"})).unwrap()["id"].as_u64().unwrap();
+    s.run("review.reply", &json!({"id": id, "text": "Totals checked"})).unwrap();
+    let opts = |s: &Session, v| cmd::file::export_options(s, &v);
+    assert!(!opts(&s, json!({})).markup, "off by default");
+    let pdf = |s: &Session, v| crate::io::save_bytes_opts("x.pdf", &s.doc, &opts(s, v)).unwrap();
+    let html = |s: &Session, v| String::from_utf8(crate::io::save_bytes_opts("x.html", &s.doc, &opts(s, v)).unwrap()).unwrap();
+    let txt = |s: &Session, v| String::from_utf8(crate::io::save_bytes_opts("x.txt", &s.doc, &opts(s, v)).unwrap()).unwrap();
+    assert!(!html(&s, json!({})).contains("Check the totals"));
+    assert!(!txt(&s, json!({})).contains("Check the totals"));
+    let plain = pdf(&s, json!({}));
+    // The setting turns it on for every copy; a command's `markup` overrides it.
+    assert_eq!(s.run("file.printMarkup", &json!({})).unwrap()["value"], true);
+    let h = html(&s, json!({}));
+    assert!(
+        h.contains("<section class=\"comments\">") && h.contains("Ada Reviewer") && h.contains("<q>figures</q>") && h.contains("Totals checked"),
+        "{h}"
+    );
+    assert!(h.find("Check the totals") < h.find("</body>"));
+    let t = txt(&s, json!({}));
+    assert!(t.contains("[1] Ada Reviewer on “figures”: Check the totals") && t.contains("Totals checked"), "{t}");
+    let md = String::from_utf8(crate::io::save_bytes_opts("x.md", &s.doc, &opts(&s, json!({}))).unwrap()).unwrap();
+    assert!(md.contains("## Comments") && md.contains("1. **Ada Reviewer**"), "{md}");
+    assert_ne!(pdf(&s, json!({})), plain);
+    assert!(!html(&s, json!({"markup": false})).contains("Check the totals"));
+    // Comments hidden in Track Changes Options stay out.
+    s.prefs.markup.comments = false;
+    assert!(!html(&s, json!({})).contains("Check the totals"));
+    s.prefs.markup.comments = true;
+    assert_eq!(s.run("file.printMarkup", &json!({"value": false})).unwrap()["value"], false);
+    assert!(html(&s, json!({"markup": true})).contains("Check the totals"));
+    // file.exportPdf and file.exportPng take it too.
+    let dir = std::env::temp_dir().join(format!("wordcraft-print-markup-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("m.pdf");
+    let r = s.run("file.exportPdf", &json!({"path": path.to_string_lossy(), "markup": true})).unwrap();
+    assert_eq!(r["markup"], true);
+    assert!(std::fs::read(&path).unwrap().starts_with(b"%PDF-"));
+    let png = dir.join("m.png");
+    let wide = s.run("file.exportPng", &json!({"path": png.to_string_lossy(), "markup": true, "scale": 1.0})).unwrap()["width"].as_u64().unwrap();
+    let narrow = s.run("file.exportPng", &json!({"path": png.to_string_lossy(), "scale": 1.0})).unwrap()["width"].as_u64().unwrap();
+    assert!(wide > narrow + 200, "{wide} vs {narrow}");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// #606: the colour commands behind More Colors… take any `RRGGBB` (with or without `#`, any
+/// case), not only the palette's colours; junk is a params error and changes nothing.
+#[test]
+fn colour_commands_take_any_custom_hex() {
+    let mut s = s();
+    run(&mut s, "text.insert", json!({"text": "Custom"}));
+    run(&mut s, "select.all", json!({}));
+    for (given, want) in [("7A3EC8", "7A3EC8"), ("#0b5d1e", "0B5D1E"), ("  ff8800 ", "FF8800")] {
+        run(&mut s, "format.color", json!({"color": given}));
+        assert_eq!(run(&mut s, "format.state", json!({})).get("color"), Some(&json!(want)));
+    }
+    let doc = s.doc.clone();
+    for junk in [json!("#12"), json!("purple"), json!("GG0000"), json!(12), json!(null), json!("ééé")] {
+        assert!(s.run("format.color", &json!({"color": junk})).is_err(), "{junk}");
+    }
+    assert_eq!(s.doc, doc);
+    run(&mut s, "format.color", json!({"color": "auto"}));
+    assert_eq!(run(&mut s, "format.state", json!({})).get("color"), Some(&json!("auto")));
+    // Shading and page colour take custom colours the same way.
+    run(&mut s, "para.shading", json!({"color": "#C0FFEE"}));
+    let shading = s.doc.para_at(&s.sel.focus).and_then(|p| p.props.shading);
+    assert_eq!(shading, wordcraft_doc::Rgb::parse("C0FFEE"));
+    run(&mut s, "design.pageColor", json!({"color": "123ABC"}));
+    assert_eq!(s.doc.settings.page_color, wordcraft_doc::Rgb::parse("123ABC"));
+}
+
+/// #569: a playlist (.m3u / .m3u8) — or any file with an extension WordCraft doesn't know —
+/// opens as plain text with its encoding detected, like Word's text import; a binary file is a
+/// clean error, never garbage or a panic.
+#[test]
+fn unknown_text_extensions_open_as_text() {
+    let lines = |doc: &wordcraft_doc::Document| doc.plain_text(StoryRef::Body);
+    let m3u8 = "#EXTM3U\r\n#EXTINF:215,Björk — Jóga\r\nmusic/Jóga.mp3\r\n#EXTINF:-1,Радио\r\nhttp://example.org/live\r\n";
+    let doc = crate::io::open_bytes("Mix.M3U8", m3u8.as_bytes()).unwrap();
+    assert!(
+        lines(&doc).starts_with("#EXTM3U\n#EXTINF:215,Björk — Jóga\nmusic/Jóga.mp3\n#EXTINF:-1,Радио\nhttp://example.org/live"),
+        "{:?}",
+        lines(&doc)
+    );
+    assert!(!lines(&doc).contains('\r'));
+    // With a BOM, which must not show up as a character.
+    let bom = [&[0xEF, 0xBB, 0xBF][..], m3u8.as_bytes()].concat();
+    assert!(lines(&crate::io::open_bytes("a.m3u8", &bom).unwrap()).starts_with("#EXTM3U\n"));
+    // A plain .m3u in Windows-1252 (é = E9, — = 97).
+    let cp1252 = b"#EXTM3U\r\n#EXTINF:100,Caf\xE9 \x97 Live\r\nC:\\Music\\caf\xE9.mp3\r\n";
+    assert_eq!(lines(&crate::io::open_bytes("old.m3u", cp1252).unwrap()), "#EXTM3U\n#EXTINF:100,Café — Live\nC:\\Music\\café.mp3\n");
+    // Other text files, a file without an extension, a dot in a folder name only.
+    for name in ["server.log", "settings.ini", "subs.srt", "README", "/home/a.b/README", "C:\\v1.2\\notes"] {
+        assert_eq!(lines(&crate::io::open_bytes(name, b"one\ntwo").unwrap()), "one\ntwo", "{name}");
+    }
+    // Binary files: an error naming the file, no panic.
+    for (name, bytes) in
+        [("song.mp3", &b"ID3\x04\0\0\0\0\x01\x02\x03"[..]), ("pic.dat", b"\x89PNG\r\n\x1a\n\0\0\0\rIHDR"), ("blob", &[0u8, 1, 2, 3, 0, 255])]
+    {
+        let err = crate::io::open_bytes(name, bytes).unwrap_err();
+        assert!(err.contains(name) && err.contains("not a document"), "{name}: {err}");
+    }
+    assert!(crate::io::open_bytes("x.pdf", b"%PDF-1.7\n1 0 obj\n").is_err());
+    // A Word document or RTF file with the wrong extension opens by what it holds.
+    let docx = crate::io::save_bytes("x.docx", &crate::sample::letter()).unwrap();
+    assert_eq!(lines(&crate::io::open_bytes("letter.bak", &docx).unwrap()), lines(&crate::io::open_bytes("x.docx", &docx).unwrap()));
+    let rtf = crate::io::open_bytes("note.tmp", br"{\rtf1\ansi Hello {\b bold}\par}").unwrap();
+    assert!(lines(&rtf).starts_with("Hello bold"), "{:?}", lines(&rtf));
+    // Through file.open, both from disk and with the bytes (the web's picker and drops).
+    let dir = std::env::temp_dir().join(format!("wordcraft-569-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("road trip.m3u");
+    std::fs::write(&path, cp1252).unwrap();
+    let mut s = s();
+    let r = run(&mut s, "file.open", json!({"path": path.to_string_lossy()}));
+    assert_eq!(r["paragraphs"], 4);
+    assert!(text(&s).contains("Café — Live"));
+    let data = crate::cmd::insert::base64_encode(m3u8.as_bytes());
+    run(&mut s, "file.open", json!({"path": "Mix.m3u8", "data": data}));
+    assert!(text(&s).contains("Радио"));
+    let bad = crate::cmd::insert::base64_encode(b"\0\x01\x02binary\0");
+    assert!(s.run("file.open", &json!({"path": "x.bin", "data": bad})).is_err());
+    assert!(text(&s).contains("Радио"), "a failed open leaves the document alone");
+    let _ = std::fs::remove_dir_all(&dir);
+}
+
+/// #549: after a double-click, dragging extends the selection by whole words; after a
+/// triple-click by whole paragraphs; after Ctrl/⌘+click by whole sentences. Forward drags keep
+/// the first unit's start as the anchor, backward drags its end.
+#[test]
+fn drag_after_multi_click_extends_by_units() {
+    let mut s = s();
+    run(&mut s, "text.insert", json!({"text": "Alpha beta gamma. Delta epsilon.\rSecond para here.\rThird one."}));
+    let drag = |s: &mut Session, unit: &str, start: Pos, end: Pos, pos: Pos| {
+        run(s, "select.dragUnit", json!({"unit": unit, "start": start, "end": end, "pos": pos}));
+        (s.sel.anchor.clone(), s.sel.focus.clone())
+    };
+    // Double-click "beta" (6..11 with its trailing space).
+    run(&mut s, "caret.set", json!({"pos": Pos::body(0, 7)}));
+    run(&mut s, "select.word", json!({}));
+    let (a, b) = s.sel.ordered();
+    assert_eq!((a.off, b.off), (6, 11));
+    // Forward into the middle of "gamma": the whole word joins.
+    assert_eq!(drag(&mut s, "word", a.clone(), b.clone(), Pos::body(0, 13)), (Pos::body(0, 6), Pos::body(0, 16)));
+    // Back into "Alpha": anchored at the end of "beta ", focus at the start of "Alpha".
+    assert_eq!(drag(&mut s, "word", a.clone(), b.clone(), Pos::body(0, 2)), (Pos::body(0, 11), Pos::body(0, 0)));
+    // Back inside the first word: just that word.
+    assert_eq!(drag(&mut s, "word", a.clone(), b.clone(), Pos::body(0, 8)), (Pos::body(0, 6), Pos::body(0, 11)));
+    // Into the next paragraph: whole word there.
+    assert_eq!(drag(&mut s, "word", a.clone(), b.clone(), Pos::body(1, 8)), (Pos::body(0, 6), Pos::body(1, 12)));
+
+    // Ctrl+click a sentence, drag into the next sentence.
+    run(&mut s, "caret.set", json!({"pos": Pos::body(0, 3)}));
+    run(&mut s, "select.sentence", json!({}));
+    let (a, b) = s.sel.ordered();
+    let (_, f) = drag(&mut s, "sentence", a, b, Pos::body(0, 20));
+    assert_eq!(f.off, 32, "the second sentence is selected to its end");
+
+    // Triple-click the second paragraph, drag up into the first and down into the third.
+    run(&mut s, "caret.set", json!({"pos": Pos::body(1, 3)}));
+    run(&mut s, "select.paragraph", json!({}));
+    let (a, b) = s.sel.ordered();
+    assert_eq!((a.clone(), b.clone()), (Pos::body(1, 0), Pos::body(2, 0)));
+    assert_eq!(drag(&mut s, "paragraph", a.clone(), b.clone(), Pos::body(0, 5)), (Pos::body(2, 0), Pos::body(0, 0)));
+    assert_eq!(drag(&mut s, "paragraph", a.clone(), b.clone(), Pos::body(2, 2)), (Pos::body(1, 0), Pos::body(2, 10)));
+
+    // Junk never panics and leaves the document alone.
+    let before = text(&s);
+    for v in [
+        json!({}),
+        json!({"unit": "line", "start": Pos::body(0, 0), "end": Pos::body(0, 1), "pos": Pos::body(0, 1)}),
+        json!({"unit": "word", "start": Pos::body(99, 999), "end": Pos::body(0, 0), "pos": Pos::body(77, usize::MAX)}),
+        json!({"unit": "word", "start": {"block": 0, "off": 9_999}, "end": {"block": 0, "off": 1}, "pos": {"block": 5}}),
+    ] {
+        let _ = s.run("select.dragUnit", &v);
+    }
+    assert_eq!(text(&s), before);
+}
+
 /// Home › Font › Enclose Characters (#297): the selection becomes an `EQ \o\ac` field, saved the
 /// way Word stores it (the style in the code's run sizes) and read back; null takes the text out
 /// again, and each step undoes.
@@ -2966,6 +3467,76 @@ fn enclose_characters_make_an_eq_field_and_come_back_out() {
     assert_eq!(field(&s), Some(("eq \\o\\ac(△,A)".to_string(), "A".to_string())));
 }
 
+#[test]
+fn replace_all_splits_paragraphs_at_a_paragraph_mark_in_the_replacement() {
+    // Issue #423: untracked Replace All left `\r` in the paragraph instead of splitting it.
+    for with in ["A\rB", "A\u{2029}B"] {
+        let mut s = s();
+        run(&mut s, "text.insert", json!({"text": "cat cat"}));
+        run(&mut s, "edit.replaceAll", json!({"text": "cat", "with": with}));
+        assert_eq!(body_texts(&s), ["A", "B A", "B"], "{with:?}");
+    }
+    // A line feed stays a line break.
+    let mut s = s();
+    run(&mut s, "text.insert", json!({"text": "cat"}));
+    run(&mut s, "edit.replaceAll", json!({"text": "cat", "with": "A\nB"}));
+    assert_eq!(body_texts(&s), ["A\nB"]);
+}
+
+/// A one-row table converted from tab-separated `text`.
+fn table_from(text: &str) -> Session {
+    let mut s = s();
+    run(&mut s, "document.setText", json!({"text": text}));
+    run(&mut s, "select.all", json!({}));
+    run(&mut s, "table.fromText", json!({}));
+    s
+}
+
+fn table_texts(s: &Session) -> Vec<Vec<String>> {
+    let t = s.doc.body.iter().find_map(|b| b.as_table()).expect("a table");
+    t.rows.iter().map(|r| r.cells.iter().map(|c| c.blocks.iter().filter_map(|b| b.as_para()).map(|p| p.text.clone()).collect()).collect()).collect()
+}
+
+#[test]
+fn delete_columns_deletes_every_selected_column() {
+    // Issue #431: only the selection's focus column went.
+    let cell = |r: u32, c: u32, off: usize| json!({"story": "body", "path": [0, r, c, 0], "off": off});
+    for (anchor, focus) in [(cell(0, 0, 0), cell(1, 1, 1)), (cell(1, 1, 1), cell(0, 0, 0))] {
+        let mut s = table_from("Left\tMiddle\tRight\nA\tB\tC");
+        run(&mut s, "select.range", json!({"anchor": anchor, "focus": focus}));
+        run(&mut s, "table.deleteColumn", json!({}));
+        assert_eq!(table_texts(&s), [["Right"], ["C"]]);
+        run(&mut s, "edit.undo", json!({}));
+        assert_eq!(table_texts(&s), [["Left", "Middle", "Right"], ["A", "B", "C"]]);
+    }
+    // A caret deletes its own column only.
+    let mut s = table_from("Left\tMiddle\tRight");
+    run(&mut s, "caret.set", json!({"pos": cell(0, 1, 0)}));
+    run(&mut s, "table.deleteColumn", json!({}));
+    assert_eq!(table_texts(&s), [["Left", "Right"]]);
+}
+
+#[test]
+fn split_cells_leaves_the_other_rows_alone() {
+    // Issue #432: splitting a cell inserted a grid column with a new cell in every row.
+    let spans = |s: &Session| -> Vec<Vec<usize>> {
+        let t = s.doc.body.iter().find_map(|b| b.as_table()).expect("a table");
+        t.rows.iter().map(|r| r.cells.iter().map(wordcraft_doc::Cell::span).collect()).collect()
+    };
+    let mut s = table_from("Left\nA");
+    let width: f32 = s.doc.body.iter().find_map(|b| b.as_table()).unwrap().total_width();
+    run(&mut s, "table.split", json!({"columns": 2}));
+    assert_eq!(table_texts(&s), [vec!["Left", ""], vec!["A"]]);
+    assert_eq!(spans(&s), [vec![1, 1], vec![2]]);
+    let t = s.doc.body.iter().find_map(|b| b.as_table()).unwrap();
+    assert!((t.total_width() - width).abs() < 0.1, "{:?}", t.grid);
+    assert!((t.grid[0] - width / 2.0).abs() < 0.1, "{:?}", t.grid);
+    let mut s = table_from("Left\tMiddle\tRight\nA\tB\tC");
+    run(&mut s, "table.split", json!({"columns": 2}));
+    assert_eq!(table_texts(&s), [vec!["Left", "", "Middle", "Right"], vec!["A", "B", "C"]]);
+    assert_eq!(spans(&s), [vec![1, 1, 1, 1], vec![2, 1, 1]]);
+}
+
 /// #385: note options for the whole document or one section, and converting notes, which undoes
 /// in one step.
 #[test]
@@ -3137,3 +3708,283 @@ fn proofing_languages_survive_a_docx_round_trip() {
         issues.as_array().unwrap().iter().map(|i| (i["text"].as_str().unwrap().to_string(), i["lang"].as_str().unwrap().to_string())).collect();
     assert_eq!(found, [("żeka".to_string(), "pl".to_string()), ("wrold".to_string(), "en".to_string())], "{issues}");
 }
+
+#[test]
+fn hide_white_space_toggles_view_state_only() {
+    let mut s = s();
+    let before = s.doc.body.len();
+    assert!(!s.view.hide_white_space);
+    assert_eq!(run(&mut s, "view.hideWhiteSpace", json!({}))["value"], true);
+    assert!(s.view.hide_white_space);
+    assert_eq!(run(&mut s, "view.hideWhiteSpace", json!({"value": false}))["value"], false);
+    assert_eq!(s.doc.body.len(), before, "a view option never edits the document");
+}
+
+/// The first SmartArt (or other graphic) in the body, selected.
+fn select_graphic(s: &mut Session) {
+    let (path, off) = (0..s.doc.body.len() as u32)
+        .find_map(|b| {
+            let p = s.doc.para(StoryRef::Body, &wordcraft_doc::Path(vec![b]))?;
+            let off = p.object_offsets().into_iter().find(|o| matches!(p.object_at(*o), Some(wordcraft_doc::InlineObject::Graphic { .. })))?;
+            Some((wordcraft_doc::Path(vec![b]), off))
+        })
+        .expect("a graphic");
+    let at = Pos { story: StoryRef::Body, path, off };
+    let end = Pos { off: off + wordcraft_doc::para::OBJ.len_utf8(), ..at.clone() };
+    s.sel = crate::Selection { anchor: at, focus: end };
+}
+
+/// #497: Insert › SmartArt saves as diagram parts (data, layout, style, colours, drawing) and
+/// reopens as the same editable graphic; an edited data part stays read-only.
+#[test]
+fn smart_art_round_trips_through_docx() {
+    use std::io::Read;
+    let mut s = s();
+    let r = run(
+        &mut s,
+        "insert.smartArt",
+        json!({"layout": "hierarchy", "items": ["Root", "\tLeft", {"text": "Right", "level": 1}], "colors": "colorful"}),
+    );
+    assert_eq!(r["smartArt"]["layout"], "hierarchy");
+    let spec = cmd::smart_art::selected_smart_art(&s).expect("selected after insert");
+    let bytes = crate::io::save_bytes("sa.docx", &s.doc).unwrap();
+    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&bytes)).unwrap();
+    for part in ["data1", "layout1", "quickStyle1", "colors1", "drawing1"] {
+        assert!(zip.by_name(&format!("word/diagrams/{part}.xml")).is_ok(), "{part} written");
+    }
+    let mut ct = String::new();
+    zip.by_name("[Content_Types].xml").unwrap().read_to_string(&mut ct).unwrap();
+    assert!(ct.contains("diagramDrawing+xml") && ct.contains("diagramData+xml"), "{ct}");
+    let mut s2 = Session::new(crate::io::open_bytes("sa.docx", &bytes).unwrap());
+    select_graphic(&mut s2);
+    assert_eq!(cmd::smart_art::selected_smart_art(&s2).as_deref(), Some(&*spec), "reopens editable");
+    run(&mut s2, "smartArt.layout", json!({"layout": "venn"}));
+    // Saved again, and once more after reopening: still the same graphic.
+    let again = crate::io::save_bytes("sa.docx", &s2.doc).unwrap();
+    let mut s3 = Session::new(crate::io::open_bytes("sa.docx", &again).unwrap());
+    select_graphic(&mut s3);
+    assert_eq!(cmd::smart_art::selected_smart_art(&s3).map(|g| g.layout), Some(wordcraft_doc::smart_art::SmartArtLayout::Venn));
+    // A data part another program rewrote: shown, not editable.
+    let mut zip = zip::ZipArchive::new(std::io::Cursor::new(&again)).unwrap();
+    let mut out = zip::ZipWriter::new(std::io::Cursor::new(Vec::new()));
+    for i in 0..zip.len() {
+        let mut f = zip.by_index(i).unwrap();
+        let name = f.name().to_string();
+        let mut buf = Vec::new();
+        f.read_to_end(&mut buf).unwrap();
+        if name.ends_with("data1.xml") {
+            buf = String::from_utf8(buf).unwrap().replace("<dgm:bg/>", "<dgm:bg><a:noFill/></dgm:bg>").into_bytes();
+        }
+        out.start_file(name, zip::write::SimpleFileOptions::default()).unwrap();
+        std::io::Write::write_all(&mut out, &buf).unwrap();
+    }
+    let foreign = out.finish().unwrap().into_inner();
+    let mut s4 = Session::new(crate::io::open_bytes("sa.docx", &foreign).unwrap());
+    select_graphic(&mut s4);
+    assert!(cmd::smart_art::selected_smart_art(&s4).is_none());
+    assert!(s4.run("smartArt.layout", &json!({"layout": "cycle"})).is_err());
+}
+
+/// #497: item, layout and colour edits are one undo step each; promote and demote move an item
+/// with the items under it.
+#[test]
+fn smart_art_edits_undo_one_step_each() {
+    let mut s = s();
+    run(&mut s, "insert.smartArt", json!({"layout": "process"}));
+    let items = |s: &Session| cmd::smart_art::selected_smart_art(s).unwrap().items.iter().map(|i| (i.text.clone(), i.level)).collect::<Vec<_>>();
+    let before = items(&s);
+    run(&mut s, "smartArt.items", json!({"items": ["One", "Two", "\tTwo a"]}));
+    assert_eq!(items(&s), [("One".to_string(), 0), ("Two".to_string(), 0), ("Two a".to_string(), 1)]);
+    run(&mut s, "smartArt.demote", json!({"index": 1}));
+    assert_eq!(items(&s)[1..], [("Two".to_string(), 1), ("Two a".to_string(), 2)]);
+    run(&mut s, "smartArt.promote", json!({"index": 1}));
+    run(&mut s, "smartArt.addShape", json!({"after": 0, "text": "New"}));
+    assert_eq!(items(&s)[1], ("New".to_string(), 0));
+    run(&mut s, "smartArt.colors", json!({"variant": "accent4"}));
+    run(&mut s, "smartArt.layout", json!({"layout": "pyramid"}));
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(cmd::smart_art::selected_smart_art(&s).unwrap().layout, wordcraft_doc::smart_art::SmartArtLayout::Process);
+    for _ in 0..5 {
+        run(&mut s, "edit.undo", json!({}));
+    }
+    assert_eq!(items(&s), before);
+    assert!(s.run("smartArt.promote", &json!({"index": 0})).is_err(), "already at the top");
+    run(&mut s, "picture.size", json!({"width": 200, "height": 120, "lockAspect": false}));
+}
+
+/// #497: hostile SmartArt params are capped or refused, never a panic.
+#[test]
+fn smart_art_hostile_params_are_capped() {
+    use wordcraft_doc::smart_art::{MAX_ITEMS, MAX_LEVEL, MAX_TEXT};
+    let mut s = s();
+    let many: Vec<serde_json::Value> = (0..MAX_ITEMS * 3).map(|i| json!({"text": "x".repeat(10_000), "level": i * 1000})).collect();
+    run(&mut s, "insert.smartArt", json!({"layout": "hierarchy", "items": many, "width": 1e30, "height": -5}));
+    let g = cmd::smart_art::selected_smart_art(&s).unwrap();
+    assert_eq!(g.items.len(), MAX_ITEMS);
+    assert!(g.items.iter().all(|i| i.text.chars().count() <= MAX_TEXT && i.level <= MAX_LEVEL));
+    for bad in [json!({"items": []}), json!({"items": "x"}), json!({"items": [5]}), json!({"layout": "spiral"}), json!({"layout": 3})] {
+        assert!(s.run("insert.smartArt", &bad).is_err(), "{bad}");
+    }
+    let junk = [json!(null), json!({}), json!({"index": -1, "after": 1e300, "items": [{"level": "deep"}], "variant": [], "layout": {}})];
+    for id in [
+        "smartArt.items",
+        "smartArt.addShape",
+        "smartArt.promote",
+        "smartArt.demote",
+        "smartArt.layout",
+        "smartArt.colors",
+        "smartArt.reset",
+        "smartArt.textPane",
+    ] {
+        for j in &junk {
+            let _ = s.run(id, j);
+        }
+    }
+    for _ in 0..MAX_ITEMS {
+        let _ = s.run("smartArt.addShape", &json!({}));
+    }
+    assert_eq!(cmd::smart_art::selected_smart_art(&s).unwrap().items.len(), MAX_ITEMS);
+    let _ = s.layout();
+}
+
+/// Outline view of: Heading 1 "One", body "a", Heading 2 "Two", body "b", Heading 1 "Three", body "c".
+fn outline_doc() -> Session {
+    let mut s = s();
+    run(&mut s, "document.setText", json!({"text": "One\na\nTwo\nb\nThree\nc"}));
+    for (i, style) in [(0, "Heading1"), (2, "Heading2"), (4, "Heading1")] {
+        s.sel = crate::Selection::caret(Pos::body(i, 0));
+        run(&mut s, "para.style", json!({"style": style}));
+    }
+    run(&mut s, "view.outline", json!({}));
+    s
+}
+
+fn outline_shown(s: &mut Session) -> Vec<u64> {
+    let st = run(s, "outline.state", json!({}));
+    st["shown"].as_array().unwrap().iter().map(|v| v.as_u64().unwrap()).collect()
+}
+
+/// The body blocks the outline layout draws.
+fn laid_out_blocks(s: &mut Session) -> Vec<u32> {
+    let l = s.layout();
+    let mut v: Vec<u32> = l.pages[0]
+        .items
+        .iter()
+        .filter_map(|it| match it {
+            wordcraft_layout::Placed::Lines { story: StoryRef::Body, path, .. } => path.0.first().copied(),
+            _ => None,
+        })
+        .collect();
+    v.dedup();
+    v
+}
+
+#[test]
+fn outline_level_changes_are_undoable() {
+    let mut s = outline_doc();
+    let level = |s: &mut Session, i: usize| run(s, "outline.state", json!({}))["levels"][i].as_u64().unwrap();
+    s.sel = crate::Selection::caret(Pos::body(1, 0));
+    run(&mut s, "outline.level", json!({"level": 3}));
+    assert_eq!(level(&mut s, 1), 3);
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(level(&mut s, 1), 10, "body text again");
+    s.sel = crate::Selection::caret(Pos::body(2, 0));
+    run(&mut s, "outline.promoteToHeading1", json!({}));
+    assert_eq!(level(&mut s, 2), 1);
+    run(&mut s, "outline.demoteToBody", json!({}));
+    assert_eq!(level(&mut s, 2), 10);
+    assert!(s.run("outline.level", &json!({"level": 12})).is_err());
+    assert!(s.run("outline.level", &json!({})).is_err());
+    // Every outline command survives junk parameters in Outline view.
+    for spec in cmd::registry().all().iter().filter(|c| c.id.starts_with("outline.")) {
+        for j in [json!(null), json!({"block": 99999, "level": "x", "value": 5}), json!({"block": -1, "level": 0})] {
+            let mut s = outline_doc();
+            let _ = s.run(spec.id, &j);
+            let _ = s.layout();
+        }
+    }
+}
+
+#[test]
+fn outline_show_level_filters_paragraphs() {
+    let mut s = outline_doc();
+    assert_eq!(outline_shown(&mut s), vec![0, 1, 2, 3, 4, 5]);
+    assert_eq!(laid_out_blocks(&mut s), vec![0, 1, 2, 3, 4, 5]);
+    run(&mut s, "outline.showLevel", json!({"level": 1}));
+    assert_eq!(outline_shown(&mut s), vec![0, 4]);
+    assert_eq!(laid_out_blocks(&mut s), vec![0, 4]);
+    run(&mut s, "outline.showLevel2", json!({}));
+    assert_eq!(outline_shown(&mut s), vec![0, 2, 4]);
+    run(&mut s, "outline.showAll", json!({}));
+    assert_eq!(outline_shown(&mut s), vec![0, 1, 2, 3, 4, 5]);
+    // Word's keys, and only in Outline view.
+    let reg = cmd::registry();
+    assert_eq!(reg.by_shortcut("Alt+Shift+1").map(|c| c.id), Some("outline.showLevel1"));
+    assert_eq!(reg.by_shortcut("Alt+Shift+A").map(|c| c.id), Some("outline.showAll"));
+    assert_eq!(reg.by_shortcut("Alt+Shift+=").map(|c| c.id), Some("outline.expand"));
+    assert_eq!(reg.by_shortcut("Alt+Shift+-").map(|c| c.id), Some("outline.collapse"));
+    run(&mut s, "outline.close", json!({}));
+    assert!(s.run("outline.showLevel1", &json!({})).is_err());
+}
+
+#[test]
+fn outline_collapse_hides_descendants_and_expand_restores() {
+    let mut s = outline_doc();
+    s.sel = crate::Selection::caret(Pos::body(0, 0));
+    // The deepest open level closes first, then the heading itself.
+    run(&mut s, "outline.collapse", json!({}));
+    assert_eq!(outline_shown(&mut s), vec![0, 1, 2, 4, 5]);
+    run(&mut s, "outline.collapse", json!({}));
+    assert_eq!(outline_shown(&mut s), vec![0, 4, 5]);
+    assert_eq!(laid_out_blocks(&mut s), vec![0, 4, 5]);
+    // A caret moving into the collapsed text goes on to the next shown paragraph.
+    run(&mut s, "caret.end", json!({}));
+    run(&mut s, "caret.right", json!({}));
+    assert_eq!(s.sel.focus, Pos::body(4, 0));
+    // Moving "Three" and "c" up passes "One" with everything collapsed under it, in one undo step.
+    s.sel = crate::Selection { anchor: Pos::body(4, 0), focus: Pos::body(5, 1) };
+    run(&mut s, "outline.moveUp", json!({}));
+    assert_eq!(text(&s), "Three\nc\nOne\na\nTwo\nb");
+    assert_eq!(outline_shown(&mut s), vec![0, 1, 2], "the collapsed heading moved and stays collapsed");
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(text(&s), "One\na\nTwo\nb\nThree\nc");
+    assert_eq!(outline_shown(&mut s), vec![0, 4, 5]);
+    // Expand opens one level at a time; double-clicking the symbol (toggle) opens it all.
+    s.sel = crate::Selection::caret(Pos::body(0, 0));
+    run(&mut s, "outline.expand", json!({}));
+    assert_eq!(outline_shown(&mut s), vec![0, 1, 2, 4, 5]);
+    run(&mut s, "outline.expand", json!({}));
+    assert_eq!(outline_shown(&mut s), vec![0, 1, 2, 3, 4, 5]);
+    run(&mut s, "outline.toggle", json!({"block": 0}));
+    assert_eq!(outline_shown(&mut s), vec![0, 4, 5]);
+    run(&mut s, "outline.toggle", json!({"block": 0}));
+    assert_eq!(outline_shown(&mut s), vec![0, 1, 2, 3, 4, 5]);
+    // Clicking a symbol selects the heading with what is under it.
+    run(&mut s, "outline.selectSubtree", json!({"block": 0}));
+    assert_eq!(s.selected_text(), "One\na\nTwo\nb");
+}
+
+#[test]
+fn format_font_sets_the_asian_and_latin_fonts_separately() {
+    // #505: Word's Font dialog sets an Asian text font and a Latin text font of their own.
+    let mut s = s();
+    run(&mut s, "document.setText", json!({"text": "Hello 你好"}));
+    run(&mut s, "select.all", json!({}));
+    let fonts = |s: &Session| {
+        let c = s.doc.para(StoryRef::Body, &wordcraft_doc::Path::top(0)).unwrap().props_of_char(0).clone();
+        (c.font, c.font_ea)
+    };
+    let before = fonts(&s);
+    run(&mut s, "format.font", json!({"name": "Georgia", "eastAsia": "SimSun"}));
+    assert_eq!(fonts(&s), (Some("Georgia".into()), Some("SimSun".into())));
+    assert_eq!(run(&mut s, "format.state", json!({}))["fontEastAsia"], "SimSun");
+    // The Asian font alone leaves the Latin font as it is.
+    run(&mut s, "format.font", json!({"eastAsia": "Noto Sans CJK SC"}));
+    assert_eq!(fonts(&s), (Some("Georgia".into()), Some("Noto Sans CJK SC".into())));
+    // Each change is one undo step.
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(fonts(&s), (Some("Georgia".into()), Some("SimSun".into())));
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(fonts(&s), before);
+    assert!(s.run("format.font", &json!({})).is_err() && s.run("format.font", &json!({"eastAsia": " "})).is_err());
+}
diff --git a/crates/engine/src/tests_fonts.rs b/crates/engine/src/tests_fonts.rs
new file mode 100644
index 0000000000..fdc54c0307
--- /dev/null
+++ b/crates/engine/src/tests_fonts.rs
@@ -0,0 +1,107 @@
+//! Fonts added at run time (#582): `font.add`, `font.list`, `font.remove`.
+
+use serde_json::json;
+use wordcraft_doc::Pos;
+
+use crate::Session;
+use crate::cmd::insert::base64_encode;
+
+/// The bundled face `file` of family `original` renamed `family` (as long as `original`), so it
+/// is a font the database doesn't have.
+fn renamed(file: &str, original: &str, family: &str) -> Vec<u8> {
+    assert_eq!(family.len(), original.len());
+    let mut data = std::fs::read(std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/fonts").join(file)).unwrap();
+    let utf16 = |s: &str| s.encode_utf16().flat_map(u16::to_be_bytes).collect::<Vec<u8>>();
+    for (from, to) in [(utf16(original), utf16(family)), (original.as_bytes().to_vec(), family.as_bytes().to_vec())] {
+        let mut i = 0;
+        while let Some(at) = data[i..].windows(from.len()).position(|w| w == from) {
+            data[i + at..i + at + to.len()].copy_from_slice(&to);
+            i += at + to.len();
+        }
+    }
+    data
+}
+
+/// The caret's x after `text` set in `font`.
+fn text_end_x(s: &mut Session, font: &str, text: &str) -> f32 {
+    s.run("document.setText", &json!({"text": text})).unwrap();
+    s.run("select.all", &json!({})).unwrap();
+    s.run("format.font", &json!({"name": font})).unwrap();
+    s.layout().caret_on(&Pos::body(0, text.len()), 0).unwrap().x
+}
+
+#[test]
+fn an_added_font_is_listed_and_lays_out_text_already_set_in_it() {
+    // A monospaced face, so it measures unlike whatever proportional font the system falls back
+    // to (Source Serif 4 itself where no system fonts are installed, as on the FreeBSD runner).
+    // The name has no Serif/Sans/Mono in it, which would pick a fallback of that kind.
+    const FAMILY: &str = "Cmdfont Face 4";
+    // Narrow letters: set monospaced they take far more room than in any proportional font.
+    const TEXT: &str = "illicit little lilies fill tiny jill";
+    let mut s = Session::new(wordcraft_doc::Document::new());
+    let mono = text_end_x(&mut s, "JetBrains Mono", TEXT);
+    // Not installed yet: the text falls back to another font.
+    let missing = text_end_x(&mut s, FAMILY, TEXT);
+    assert!((missing - mono).abs() > 1.0, "the fallback measures differently: {missing} vs {mono}");
+
+    let data = base64_encode(&renamed("JetBrainsMono-Regular.ttf", "JetBrains Mono", FAMILY));
+    let r = s.run("font.add", &json!({"data": data, "name": "CmdfontFace4-Regular.ttf"})).unwrap();
+    assert_eq!(r["families"], json!([FAMILY]));
+    assert_eq!(r["faces"][0]["style"], "Regular");
+    // The text already set in it re-lays out with it, without touching the document.
+    let x = s.layout().caret_on(&Pos::body(0, TEXT.len()), 0).unwrap().x;
+    assert!((x - mono).abs() < 0.01, "measured with the added font: {x} vs {mono} (missing {missing})");
+
+    let list = s.run("font.list", &json!({"all": true})).unwrap();
+    assert!(list["fonts"].as_array().unwrap().iter().any(|f| f["families"] == json!([FAMILY])));
+    assert!(list["families"].as_array().unwrap().iter().any(|f| f == FAMILY));
+    // It exports to PDF like any other font.
+    assert!(crate::io::save_bytes("out.pdf", &s.doc).unwrap().starts_with(b"%PDF"));
+
+    // Adding it again changes nothing.
+    let again = s.run("font.add", &json!({"data": data, "name": "again.ttf"}));
+    assert!(again.unwrap_err().to_string().contains("already available"));
+
+    let removed = s.run("font.remove", &json!({"family": FAMILY})).unwrap();
+    assert_eq!(removed["removed"].as_array().unwrap().len(), 1);
+    let x = s.layout().caret_on(&Pos::body(0, TEXT.len()), 0).unwrap().x;
+    assert!((x - missing).abs() < 0.01, "falls back again once removed");
+    assert!(s.run("font.remove", &json!({"family": FAMILY})).is_err());
+}
+
+#[test]
+fn adding_a_font_never_changes_text_that_does_not_use_it() {
+    const FAMILY: &str = "Metric Serif 4";
+    let mut s = Session::new(crate::sample::sample_document());
+    let before = s.layout();
+    let positions = |s: &mut Session| {
+        let l = s.layout();
+        (0..s.doc.body.len().min(12)).filter_map(|b| l.caret_on(&Pos::body(b, 0), 0).map(|c| (c.page, c.x, c.top))).collect::<Vec<_>>()
+    };
+    let a = positions(&mut s);
+    s.run("font.add", &json!({"data": base64_encode(&renamed("SourceSerif4-Bold.ttf", "Source Serif 4", FAMILY)), "name": "m.ttf"})).unwrap();
+    assert_eq!(positions(&mut s), a);
+    assert_eq!(s.layout().pages.len(), before.pages.len());
+}
+
+#[test]
+fn bad_font_input_is_an_error() {
+    let mut s = Session::new(wordcraft_doc::Document::new());
+    for p in [
+        json!({"data": base64_encode(b"definitely not a font")}),
+        json!({"data": "%%% not base64"}),
+        json!({"data": base64_encode(b"wOF2\0\x01\0\0\xff\xff\xff\xff")}),
+        json!({"path": "/nonexistent/font.ttf"}),
+        json!({"path": env!("CARGO_MANIFEST_DIR")}),
+        json!({"path": concat!(env!("CARGO_MANIFEST_DIR"), "/Cargo.toml")}),
+        json!({"url": "https://fonts.googleapis.com/css2?family=Roboto"}),
+    ] {
+        assert!(s.run("font.add", &p).is_err(), "{p}");
+    }
+    assert!(s.run("font.remove", &json!({})).is_err());
+    assert!(s.run("font.remove", &json!({"family": "Source Sans 3"})).is_err(), "the bundled fonts stay");
+    // No file: the UI is asked for a picker.
+    let r = s.run("font.add", &json!({})).unwrap();
+    assert_eq!(r["pending"], true);
+    assert!(s.ui_requests.iter().any(|r| r["open"] == "addFont"));
+}
diff --git a/crates/engine/src/tests_typing.rs b/crates/engine/src/tests_typing.rs
index 4e61144c67..8a39a608b6 100644
--- a/crates/engine/src/tests_typing.rs
+++ b/crates/engine/src/tests_typing.rs
@@ -185,6 +185,23 @@ fn autocorrect_as_you_type() {
     assert_eq!(s.doc.plain_text(StoryRef::Body), "½ cup. iPhone. See readme.txt ");
 }
 
+#[test]
+fn autocorrect_options_change_what_typing_does() {
+    let mut s = s();
+    // A user entry, a deleted built-in entry, an added exception; names of days.
+    run(&mut s, "tools.autocorrect", json!({"add": {"from": "wc", "to": "WordCraft"}}));
+    run(&mut s, "tools.autocorrect", json!({"delete": "teh"}));
+    run(&mut s, "tools.autocorrect", json!({"addException": "approx."}));
+    typ(&mut s, "wc ships on monday. teh end is approx. three weeks ");
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "WordCraft ships on Monday. Teh end is approx. three weeks ");
+    // AutoFormat options off: straight quotes, no dashes, no list; sentences not capitalised.
+    let mut s = self::s();
+    run(&mut s, "tools.autocorrect", json!({"smartQuotes": false, "dashes": false, "bullets": false, "capSentences": false, "capDays": false}));
+    typ(&mut s, "* \"hi\" a -- b sunday ");
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "* \"hi\" a -- b sunday ");
+    assert_eq!(paras(&s)[0].1, None);
+}
+
 #[test]
 fn enter_finishes_a_word_for_autocorrect() {
     let s = typed("hello\nteh end\n");
@@ -240,6 +257,59 @@ fn border_line_autoformat() {
     assert!(s.doc.para_at(&Pos::body(1, 0)).unwrap().props.borders.is_none());
 }
 
+#[test]
+fn undo_right_after_a_border_line_brings_the_characters_back() {
+    let mut s = typed("Above\n---\n");
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "Above\n");
+    run(&mut s, "edit.undo", json!({}));
+    // The AutoFormat is undone on its own: the characters are back, the Enter stays.
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "Above\n---\n");
+    assert!(s.doc.body.iter().filter_map(|b| b.as_para()).all(|p| p.props.borders.is_none()));
+    assert_eq!(s.sel.focus, Pos::body(2, 0));
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "Above\n---");
+}
+
+#[test]
+fn plus_and_hyphen_line_becomes_a_table() {
+    let mut s = typed("+--+------+\nA");
+    let Some(wordcraft_doc::Block::Table(t)) = s.doc.body.first().map(|b| &**b) else { panic!("no table: {:?}", paras(&s)) };
+    assert_eq!(t.rows.len(), 1);
+    assert_eq!(t.grid.len(), 2);
+    assert!((t.grid[1] / t.grid[0] - 3.0).abs() < 0.01, "widths follow the hyphens: {:?}", t.grid);
+    assert_eq!(t.rows[0].cells[0].blocks[0].as_para().map(|p| p.text.as_str()), Some("A"), "the caret is in the first cell");
+    assert!(s.doc.body.get(1).and_then(|b| b.as_para()).is_some_and(|p| p.is_empty()), "a paragraph follows the table");
+    // Undo right after brings the typed characters back, the Enter stays.
+    run(&mut s, "edit.undo", json!({}));
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "+--+------+\n");
+    assert!(s.doc.body.iter().all(|b| b.as_para().is_some()));
+    // Not a table: text around it, or more columns than a table can hold.
+    let s = typed("x +--+--+\n");
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "X +--+--+\n");
+    let s = typed(&format!("+{}\n", "-+".repeat(64)));
+    assert!(s.doc.body.iter().all(|b| b.as_para().is_some()));
+}
+
+#[test]
+fn arrow_bullets() {
+    for (keys, bullet) in [("> ", "\u{27A2}"), ("-> ", "\u{2794}"), ("=> ", "\u{21E8}")] {
+        let s = typed(&format!("{keys}item\nnext"));
+        assert_eq!(paras(&s), vec![para("Item", Some(0)), para("next", Some(0))], "{keys}");
+        assert_eq!(label_at(&s, 0), bullet, "{keys}");
+    }
+    // An arrow list doesn't join a plain bullet list.
+    let s = typed("* a\n\n> b");
+    assert_eq!(label_at(&s, 0), "\u{2022}");
+    assert_eq!(label_at(&s, 1), "\u{27A2}");
+}
+
+#[test]
+fn smileys_are_replaced_inside_words_too() {
+    let s = typed("so ok:) sad:( meh:| :) fine:-) ");
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "So ok\u{263A} sad\u{2639} meh\u{1F610} \u{263A} fine\u{263A} ");
+}
+
 #[test]
 fn a_large_mixed_document_types_like_word() {
     // The corpus typed into Word and WordCraft side by side; the paragraph structure must match.
@@ -378,6 +448,88 @@ fn typing_at_either_end_of_a_link_is_not_linked() {
     assert_eq!(links(&s), [("sixte".into(), false), (String::new(), false)]);
 }
 
+#[test]
+fn typing_then_selecting_then_typing_are_two_undo_steps() {
+    // #419: a selection that moves the insertion point ends the typing group, like a caret move.
+    let mut s = typed("alpha");
+    run(&mut s, "select.text", json!({"text": "ph"}));
+    run(&mut s, "text.insert", json!({"text": "X"}));
+    assert_eq!(s.doc.para_at(&Pos::body(0, 0)).unwrap().text, "alXa");
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(s.doc.para_at(&Pos::body(0, 0)).unwrap().text, "alpha");
+    assert_eq!(s.selected_text(), "ph");
+    assert!(s.can_undo());
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(s.doc.para_at(&Pos::body(0, 0)).unwrap().text, "");
+    // Uninterrupted typing (a read-only command in between included) is still one step.
+    let mut s = typed("alpha");
+    run(&mut s, "document.inspect", json!({}));
+    typ(&mut s, "X");
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(s.doc.para_at(&Pos::body(0, 0)).unwrap().text, "");
+}
+
+#[test]
+fn undoing_bold_at_the_caret_turns_bold_typing_off_again() {
+    // #424: Bold at a caret in an empty paragraph, Undo, type: the text isn't bold.
+    let mut s = s();
+    run(&mut s, "format.bold", json!({"value": true}));
+    run(&mut s, "edit.undo", json!({}));
+    assert_ne!(s.typing_props().bold, Some(true));
+    typ(&mut s, "abc");
+    let p = s.doc.para_at(&Pos::body(0, 0)).unwrap();
+    assert_eq!(p.text, "abc");
+    assert_ne!(p.props_of_char(0).bold, Some(true));
+    // Redo brings bold typing back.
+    let mut s = Session::new(wordcraft_doc::Document::new());
+    run(&mut s, "format.bold", json!({"value": true}));
+    run(&mut s, "edit.undo", json!({}));
+    run(&mut s, "edit.redo", json!({}));
+    typ(&mut s, "abc");
+    assert_eq!(s.doc.para_at(&Pos::body(0, 0)).unwrap().props_of_char(0).bold, Some(true));
+}
+
+/// Myanmar (#604): typed in memory order (consonant, medial, then the prevowel ေ that is drawn
+/// before it), the caret steps over whole syllables and Backspace removes one sign at a time.
+#[test]
+fn myanmar_typing_steps_by_syllable_and_backspaces_by_sign() {
+    // ကြေး ("money"): က + ြ + ေ + း, then မြန်မာ.
+    let word = "\u{1000}\u{103C}\u{1031}\u{1038}";
+    let mut s = typed(word);
+    assert_eq!(paras(&s), vec![para(word, None)]);
+    // Backspace takes the visarga, then the vowel sign: the consonant and medial stay.
+    typ(&mut s, "\u{8}");
+    assert_eq!(paras(&s)[0].0, "\u{1000}\u{103C}\u{1031}");
+    typ(&mut s, "\u{8}\u{1031}\u{1038}");
+    assert_eq!(paras(&s)[0].0, word, "retyped");
+    // Left from the end skips the whole syllable (the visarga and aa signs aren't grapheme
+    // extenders, so a grapheme step would stop inside it).
+    let mut s = typed("\u{1019}\u{102C}\u{1005}\u{102C}"); // မာစာ
+    run(&mut s, "caret.left", json!({}));
+    assert_eq!(s.sel.focus.off, 6);
+    run(&mut s, "caret.left", json!({}));
+    assert_eq!(s.sel.focus.off, 0);
+    run(&mut s, "caret.right", json!({}));
+    assert_eq!(s.sel.focus.off, 6);
+    // Delete removes the whole syllable after the caret.
+    run(&mut s, "text.delete", json!({}));
+    assert_eq!(paras(&s)[0].0, "\u{1019}\u{102C}");
+}
+
+/// Devanagari and Khmer: Backspace removes the last character (a matra), not the conjunct.
+#[test]
+fn indic_and_khmer_backspace_removes_one_character() {
+    let mut s = typed("\u{0915}\u{094D}\u{0937}\u{093F}\u{8}"); // क्षि ⌫
+    assert_eq!(paras(&s)[0].0, "\u{0915}\u{094D}\u{0937}");
+    typ(&mut s, "\u{8}");
+    assert_eq!(paras(&s)[0].0, "\u{0915}\u{094D}");
+    let s = typed("\u{1781}\u{17D2}\u{1798}\u{17C2}\u{8}"); // ខ្មែ ⌫
+    assert_eq!(paras(&s)[0].0, "\u{1781}\u{17D2}\u{1798}");
+    // Latin keeps grapheme Backspace: e + combining acute goes as one.
+    let s = typed("ae\u{301}\u{8}");
+    assert_eq!(paras(&s)[0].0, "a");
+}
+
 /// Press a shortcut the way the keyboard does: run the command bound to it.
 fn press(s: &mut Session, combo: &str) -> Result<serde_json::Value, crate::CmdError> {
     let id = s.registry.by_shortcut(combo).map(|c| c.id).unwrap_or_else(|| panic!("nothing bound to {combo}"));
@@ -481,3 +633,75 @@ fn shift_f5_goes_back_through_the_last_edits() {
     assert_eq!(back(), Pos::body(2, 5), "then round again");
     assert!(Session::new(wordcraft_doc::Document::new()).run("edit.goBack", &json!({})).is_err(), "nothing edited yet");
 }
+
+/// File › Options › Advanced, "Typing replaces selected text" (#485): on (Word's default) the
+/// typed text replaces the selection; off, it goes in front of the selection and keeps it.
+#[test]
+fn typing_over_a_selection_follows_the_replace_selection_option() {
+    let mut s = typed("One two");
+    run(&mut s, "select.text", json!({"text": "two"}));
+    typ(&mut s, "X");
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "One X");
+    let mut s = typed("One two");
+    run(&mut s, "file.options", json!({"typingReplacesSelection": false}));
+    run(&mut s, "select.text", json!({"text": "two"}));
+    typ(&mut s, "XY");
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "One XYtwo");
+}
+
+/// Overtype (#485): typed characters replace the ones after the caret, never past the end of the
+/// paragraph; the Insert key toggles it only with "Use the Insert key to control overtype" on
+/// (the UI checks that option; `text.overtype` is the switch).
+#[test]
+fn overtype_replaces_the_characters_after_the_caret() {
+    let mut s = typed("Abcdef\nXy");
+    run(&mut s, "caret.set", json!({"pos": Pos::body(0, 1)}));
+    run(&mut s, "text.overtype", json!({"value": true}));
+    typ(&mut s, "XY");
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "AXYdef\nXy");
+    run(&mut s, "caret.set", json!({"pos": Pos::body(0, 5)}));
+    typ(&mut s, "123");
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "AXYde123\nXy", "the paragraph mark isn't typed over");
+    run(&mut s, "text.overtype", json!({}));
+    run(&mut s, "caret.set", json!({"pos": Pos::body(0, 0)}));
+    typ(&mut s, "Z");
+    assert_eq!(s.doc.plain_text(StoryRef::Body), "ZAXYde123\nXy", "insert mode again");
+}
+
+#[test]
+fn reject_all_takes_out_the_paragraph_breaks_a_tracked_paste_inserted() {
+    // Issue #417: Paste's paragraph marks weren't tracked, so Reject All left the split.
+    for text in ["X\nY", "\n"] {
+        let mut s = s();
+        run(&mut s, "text.insert", json!({"text": "AB", "raw": true}));
+        run(&mut s, "caret.set", json!({"pos": {"block": 0, "off": 1}}));
+        run(&mut s, "review.trackChanges", json!({"value": true}));
+        run(&mut s, "edit.paste", json!({"text": text}));
+        let (head, tail) = text.split_once('\n').unwrap_or_default();
+        assert_eq!(texts(&s), [format!("a{}", head.to_lowercase()), format!("{}b", tail.to_lowercase())], "{text:?}");
+        let pasted = texts(&s);
+        run(&mut s, "review.rejectAll", json!({}));
+        assert_eq!(texts(&s), ["ab"], "{text:?}");
+        assert!(s.doc.revisions.is_empty(), "{text:?}");
+        run(&mut s, "edit.undo", json!({}));
+        run(&mut s, "review.acceptAll", json!({}));
+        assert_eq!(texts(&s), pasted, "{text:?}: accepting keeps the break");
+    }
+}
+
+#[test]
+fn plain_text_paste_keeps_an_empty_paragraph_in_a_list() {
+    // Issue #422: the pasted paragraph separators went through Enter, which ends the list on an
+    // empty item, so `A\n\nB` lost its empty paragraph.
+    for (id, v) in [("edit.pasteText", json!({"text": "A\n\nB"})), ("edit.pasteSpecial", json!({"as": "text", "text": "A\n\nB"}))] {
+        let mut s = s();
+        run(&mut s, "para.bullets", json!({}));
+        run(&mut s, id, v);
+        assert_eq!(texts(&s), ["a", "", "b"], "{id}");
+    }
+    // Enter twice still ends the list.
+    let mut s = s();
+    run(&mut s, "para.bullets", json!({}));
+    typ(&mut s, "A\n\nB");
+    assert_eq!(paras(&s), vec![para("A", Some(0)), para("B", None)]);
+}
diff --git a/crates/engine/src/tests_wordart.rs b/crates/engine/src/tests_wordart.rs
new file mode 100644
index 0000000000..9c7b63bd08
--- /dev/null
+++ b/crates/engine/src/tests_wordart.rs
@@ -0,0 +1,141 @@
+//! WordArt and connectors through the commands.
+
+use serde_json::json;
+use wordcraft_doc::connector::{ConnEnd, ShapeExtra, ends};
+use wordcraft_doc::para::{Anchor, Float, InlineObject, ShapeKind, Wrap};
+use wordcraft_doc::props::CharProps;
+use wordcraft_doc::{Document, Paragraph, Pos, StoryRef, para_block};
+
+use crate::Session;
+
+fn run(s: &mut Session, id: &str, v: serde_json::Value) -> serde_json::Value {
+    s.run(id, &v).unwrap_or_else(|e| panic!("{id}: {e}"))
+}
+
+/// A page-placed rectangle (id 1) at x 100 and ellipse (id 2) at x 300, 72 × 36 at y 200, and an
+/// elbow connector from the rectangle's right side to the ellipse's left side, all in body
+/// paragraph 0 after "Body " (objects at 5, 8, 11).
+fn joined() -> Session {
+    let float = |x: f32| Float { wrap: Wrap::InFrontOfText, h_rel: Anchor::Page, v_rel: Anchor::Page, x, y: 200.0, ..Default::default() };
+    let shape = |kind, x, extra| InlineObject::Shape {
+        kind,
+        w: 72.0,
+        h: 36.0,
+        fill: None,
+        stroke: None,
+        stroke_width: 1.0,
+        float: float(x),
+        story: None,
+        freeform: None,
+        effects: Default::default(),
+        extra,
+    };
+    let link = ShapeExtra { start: Some(ConnEnd { id: 1, site: 3 }), end: Some(ConnEnd { id: 2, site: 2 }), ..Default::default() };
+    let mut p = Paragraph::with_text("Body ", CharProps::default());
+    for o in [
+        shape(ShapeKind::Rectangle, 100.0, ShapeExtra { id: 1, ..Default::default() }),
+        shape(ShapeKind::Ellipse, 300.0, ShapeExtra { id: 2, ..Default::default() }),
+        shape(ShapeKind::ElbowConnector, 0.0, link),
+    ] {
+        let end = p.len();
+        p.insert_object(end, o, &CharProps::default()).unwrap();
+    }
+    let mut d = Document::new();
+    d.body = vec![para_block(p)];
+    Session::new(d)
+}
+
+fn select(s: &mut Session, off: usize) {
+    run(s, "select.range", json!({"anchor": Pos::body(0, off), "focus": Pos::body(0, off + 3)}));
+}
+
+/// The connector's start and end on the page.
+fn connector_ends(s: &mut Session) -> ((f32, f32), (f32, f32)) {
+    let pos = Pos::body(0, 11);
+    let hit = s.layout().object(&pos, 0).unwrap();
+    let Some(InlineObject::Shape { float, .. }) = s.doc.para_at(&pos).and_then(|p| p.object_at(pos.off)) else { panic!() };
+    let r = hit.rect;
+    let (a, b) = ends(r.x, r.y, r.w, r.h, float.flip_h, float.flip_v);
+    let round = |p: (f32, f32)| ((p.0 * 100.0).round() / 100.0, (p.1 * 100.0).round() / 100.0);
+    (round(a), round(b))
+}
+
+#[test]
+fn moving_a_joined_shape_reroutes_its_connector() {
+    let mut s = joined();
+    select(&mut s, 5);
+    run(&mut s, "arrange.nudge", json!({"dx": 0, "dy": 30}));
+    // From the rectangle's right side (172, 248) to the ellipse's left side (300, 218).
+    assert_eq!(connector_ends(&mut s), ((172.0, 248.0), (300.0, 218.0)));
+    // Resizing the ellipse moves the end with its site.
+    select(&mut s, 8);
+    run(&mut s, "arrange.bounds", json!({"width": 100, "height": 60}));
+    assert_eq!(connector_ends(&mut s).1, (300.0, 230.0));
+    // One undo takes the resize and the re-route back.
+    run(&mut s, "edit.undo", json!({}));
+    assert_eq!(connector_ends(&mut s), ((172.0, 248.0), (300.0, 218.0)));
+}
+
+#[test]
+fn dragging_a_connector_end_glues_it_to_the_nearest_site() {
+    let mut s = joined();
+    select(&mut s, 11);
+    // Dropped near the ellipse's top: glued there.
+    run(&mut s, "shape.connect", json!({"end": {"x": 340.0, "y": 195.0}}));
+    let ext = |s: &Session| match s.doc.para_at(&Pos::body(0, 11)).and_then(|p| p.object_at(11)) {
+        Some(InlineObject::Shape { extra, .. }) => extra.clone(),
+        o => panic!("{o:?}"),
+    };
+    assert_eq!(ext(&s).end, Some(ConnEnd { id: 2, site: 0 }));
+    assert_eq!(connector_ends(&mut s).1, (336.0, 200.0));
+    // Dropped in the open: a free end there.
+    run(&mut s, "shape.connect", json!({"start": {"x": 20.0, "y": 30.0}}));
+    assert_eq!(ext(&s).start, None);
+    assert_eq!(connector_ends(&mut s).0, (20.0, 30.0));
+    // Glued by reference; a site the shape doesn't have is refused.
+    run(&mut s, "shape.connect", json!({"start": {"path": [0], "off": 5, "site": 1}}));
+    assert_eq!(connector_ends(&mut s).0, (100.0, 218.0));
+    assert!(s.run("shape.connect", &json!({"start": {"path": [0], "off": 5, "site": 40}})).is_err());
+    assert!(s.run("shape.connect", &json!({"start": {"path": [0], "off": 11}})).is_err(), "not to itself");
+    // A connection to a shape that is gone is ignored.
+    select(&mut s, 8);
+    run(&mut s, "text.delete", json!({}));
+    select(&mut s, 5);
+    run(&mut s, "arrange.nudge", json!({"dx": 1}));
+}
+
+#[test]
+fn wordart_is_inserted_styled_and_bent() {
+    let mut s = Session::new(Document::new());
+    let r = run(&mut s, "insert.wordArt", json!({"text": "Hello", "style": "gradient", "transform": "textArchUp"}));
+    let id = r["story"].as_u64().unwrap() as u32;
+    assert_eq!(s.doc.plain_text(StoryRef::Part(id)), "Hello");
+    let props = s.doc.para_at(&s.doc.start_of(StoryRef::Part(id))).unwrap().props_at(0).clone();
+    assert!(matches!(props.text_effects.as_deref().and_then(|f| f.fill.as_ref()), Some(wordcraft_doc::wordart::TextFill::Gradient { .. })));
+    // Its text is drawn from outlines, bent.
+    let layout = s.layout();
+    let draws = wordcraft_layout::display::page_display(&s.doc, &layout.pages[0], &Default::default());
+    assert!(draws.iter().any(|d| matches!(d, wordcraft_layout::display::Draw::Art { .. })));
+    // The PDF draws the gradient and keeps the text.
+    let pdf = wordcraft_pdf::export(&s.doc, &Default::default()).unwrap();
+    assert!(pdf.starts_with(b"%PDF"));
+    // Effects and transforms on the selected text box's text; hostile values are refused or capped.
+    run(&mut s, "format.textEffects", json!({"outline": {"color": "C00000", "width": 1e9}, "glow": 5}));
+    let props = s.doc.para_at(&s.doc.start_of(StoryRef::Part(id))).unwrap().props_at(0).clone();
+    let fx = props.text_effects.unwrap();
+    assert_eq!(fx.outline.map(|o| o.width), Some(wordcraft_doc::wordart::MAX_OUTLINE));
+    assert!(fx.glow.is_some() && fx.fill.is_some());
+    run(&mut s, "wordArt.transform", json!({"preset": "textWave1", "adj": 1e300}));
+    assert!(s.run("wordArt.transform", &json!({"preset": "textBogus"})).is_err());
+    assert!(s.run("format.textEffects", &json!({"style": "word"})).is_err());
+    assert!(s.run("format.textEffects", &json!({"glow": "much"})).is_err());
+    let warp = s.doc.para_at(&Pos::body(0, 0)).and_then(|p| p.object_at(0)).and_then(|o| match o {
+        InlineObject::Shape { extra, .. } => extra.warp.clone(),
+        _ => None,
+    });
+    assert_eq!(
+        warp.map(|w| (w.adj_value("adj"), w.preset)).map(|(a, p)| (p, a)),
+        Some(("textWave1".into(), Some(wordcraft_doc::wordart::MAX_ADJ_VALUE)))
+    );
+    run(&mut s, "wordArt.transform", json!({"preset": "none"}));
+}
diff --git a/crates/engine/tests/safe_save.rs b/crates/engine/tests/safe_save.rs
new file mode 100644
index 0000000000..8b40f1fbb4
--- /dev/null
+++ b/crates/engine/tests/safe_save.rs
@@ -0,0 +1,171 @@
+//! Original synthetic save cases. Every test owns its directory and document copies.
+#![cfg(not(target_arch = "wasm32"))]
+
+use std::path::{Path, PathBuf};
+use std::sync::atomic::{AtomicU64, Ordering};
+
+use serde_json::json;
+use wordcraft_doc::{Document, StoryRef};
+use wordcraft_engine::{Session, io};
+
+struct Scratch(PathBuf);
+impl Scratch {
+    fn new() -> Self {
+        static NEXT: AtomicU64 = AtomicU64::new(0);
+        let path = std::env::temp_dir().join(format!("wordcraft-safe-save-test-{}-{}", std::process::id(), NEXT.fetch_add(1, Ordering::Relaxed)));
+        std::fs::create_dir(&path).unwrap();
+        Self(path)
+    }
+    fn path(&self, name: &str) -> PathBuf {
+        self.0.join(name)
+    }
+    fn names(&self) -> Vec<String> {
+        let mut names: Vec<_> = std::fs::read_dir(&self.0).unwrap().map(|e| e.unwrap().file_name().to_string_lossy().into_owned()).collect();
+        names.sort();
+        names
+    }
+}
+impl Drop for Scratch {
+    fn drop(&mut self) {
+        let _ = std::fs::remove_dir_all(&self.0);
+    }
+}
+fn original(path: &Path) -> Vec<u8> {
+    let bytes = io::save_bytes("original.docx", &Document::from_text("Original synthetic contract.")).unwrap();
+    std::fs::write(path, &bytes).unwrap();
+    bytes
+}
+fn edited() -> Document {
+    Document::from_text("Original synthetic contract. Edited sentinel.")
+}
+fn saved(path: &Path) {
+    assert_eq!(io::open_path(path).unwrap().plain_text(StoryRef::Body), edited().plain_text(StoryRef::Body));
+}
+
+#[test]
+fn an_existing_temporary_file_is_not_overwritten_or_removed() {
+    let d = Scratch::new();
+    let path = d.path("contract.docx");
+    original(&path);
+    let neighbour = d.path("contract.docx.tmp");
+    std::fs::write(&neighbour, b"Keep this existing sibling.").unwrap();
+    io::save_path(&path, &edited()).unwrap();
+    saved(&path);
+    assert_eq!(std::fs::read(&neighbour).unwrap(), b"Keep this existing sibling.");
+    assert_eq!(d.names(), ["contract.docx", "contract.docx.tmp"]);
+}
+
+#[test]
+fn an_existing_temporary_directory_does_not_block_a_save() {
+    let d = Scratch::new();
+    let path = d.path("contract.docx");
+    original(&path);
+    let neighbour = d.path("contract.docx.tmp");
+    std::fs::create_dir(&neighbour).unwrap();
+    std::fs::write(neighbour.join("keep"), b"Keep this directory.").unwrap();
+    io::save_path(&path, &edited()).unwrap();
+    saved(&path);
+    assert_eq!(std::fs::read(neighbour.join("keep")).unwrap(), b"Keep this directory.");
+}
+
+#[cfg(unix)]
+#[test]
+fn temporary_links_cannot_redirect_a_save_into_the_original_or_a_neighbour() {
+    for link_to_original in [false, true] {
+        let d = Scratch::new();
+        let path = d.path("contract.docx");
+        original(&path);
+        let other = d.path("neighbour.txt");
+        std::fs::write(&other, b"Keep this neighbour.").unwrap();
+        let link = d.path("contract.docx.tmp");
+        let target = if link_to_original { &path } else { &other };
+        std::os::unix::fs::symlink(target, &link).unwrap();
+        io::save_path(&path, &edited()).unwrap();
+        assert!(!path.is_symlink());
+        saved(&path);
+        assert_eq!(std::fs::read_link(&link).unwrap(), *target);
+        assert_eq!(std::fs::read(&other).unwrap(), b"Keep this neighbour.");
+    }
+}
+
+#[test]
+fn failed_save_as_keeps_original_dirty_session_and_destination() {
+    let d = Scratch::new();
+    let path = d.path("original.docx");
+    let bytes = original(&path);
+    let blocked = d.path("blocked.docx");
+    std::fs::create_dir(&blocked).unwrap();
+    std::fs::write(blocked.join("keep"), b"Keep this destination.").unwrap();
+    let mut s = Session::new(edited());
+    s.path = Some(path.clone());
+    s.dirty = true;
+    let before = s.doc.plain_text(StoryRef::Body);
+    assert!(s.run("file.saveAs", &json!({"path": blocked})).is_err());
+    assert!(s.dirty);
+    assert_eq!(s.path.as_ref(), Some(&path));
+    assert_eq!(s.doc.plain_text(StoryRef::Body), before);
+    assert_eq!(std::fs::read(&path).unwrap(), bytes);
+    assert_eq!(std::fs::read(blocked.join("keep")).unwrap(), b"Keep this destination.");
+    assert_eq!(d.names(), ["blocked.docx", "original.docx"]);
+}
+
+#[test]
+fn successful_save_as_keeps_original_and_updates_session_only_after_saving() {
+    let d = Scratch::new();
+    let path = d.path("original.docx");
+    let bytes = original(&path);
+    let copy = d.path("copy.docx");
+    let mut s = Session::new(edited());
+    s.path = Some(path.clone());
+    s.dirty = true;
+    s.run("file.saveAs", &json!({"path": copy})).unwrap();
+    assert!(!s.dirty);
+    assert_eq!(s.path.as_ref(), Some(&copy));
+    assert_eq!(std::fs::read(path).unwrap(), bytes);
+    saved(&copy);
+    assert_eq!(d.names(), ["copy.docx", "original.docx"]);
+}
+
+#[test]
+fn missing_parent_keeps_original_and_session_unchanged() {
+    let d = Scratch::new();
+    let path = d.path("original.docx");
+    let bytes = original(&path);
+    let mut s = Session::new(edited());
+    s.path = Some(path.clone());
+    s.dirty = true;
+    assert!(s.run("file.saveAs", &json!({"path": d.path("missing/copy.docx")})).is_err());
+    assert!(s.dirty);
+    assert_eq!(s.path, Some(path.clone()));
+    assert_eq!(std::fs::read(path).unwrap(), bytes);
+    assert_eq!(d.names(), ["original.docx"]);
+}
+
+#[test]
+fn encrypted_save_reopens_only_with_password_and_leaves_neighbours_alone() {
+    let d = Scratch::new();
+    let path = d.path("contract.docx");
+    original(&path);
+    let neighbour = d.path("contract.docx.tmp");
+    std::fs::write(&neighbour, b"Keep this sibling.").unwrap();
+    io::save_path_with(&path, &edited(), Some("synthetic-test-password"), &io::ExportOptions::default()).unwrap();
+    assert!(io::needs_password(&io::open_path(&path).unwrap_err()));
+    let (doc, encrypted) = io::open_path_with(&path, Some("synthetic-test-password")).unwrap();
+    assert!(encrypted);
+    assert_eq!(doc.plain_text(StoryRef::Body), edited().plain_text(StoryRef::Body));
+    assert_eq!(std::fs::read(&neighbour).unwrap(), b"Keep this sibling.");
+    assert_eq!(d.names(), ["contract.docx", "contract.docx.tmp"]);
+}
+
+#[cfg(unix)]
+#[test]
+fn replacement_keeps_existing_unix_permissions() {
+    use std::os::unix::fs::PermissionsExt;
+    let d = Scratch::new();
+    let path = d.path("contract.docx");
+    original(&path);
+    std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).unwrap();
+    io::save_path(&path, &edited()).unwrap();
+    saved(&path);
+    assert_eq!(std::fs::metadata(&path).unwrap().permissions().mode() & 0o777, 0o600);
+}
diff --git a/crates/fonts/Cargo.toml b/crates/fonts/Cargo.toml
index ef97b4da07..9107da44f1 100644
--- a/crates/fonts/Cargo.toml
+++ b/crates/fonts/Cargo.toml
@@ -12,5 +12,7 @@ workspace = true
 kurbo = { workspace = true }
 skrifa = { workspace = true }
 harfrust = { workspace = true }
+wuff = { workspace = true }
 unicode-bidi = { workspace = true }
+unicode-script = { workspace = true }
 log = { workspace = true }
diff --git a/crates/fonts/src/fontdb.rs b/crates/fonts/src/fontdb.rs
index db1180ef11..5b21cb4c04 100644
--- a/crates/fonts/src/fontdb.rs
+++ b/crates/fonts/src/fontdb.rs
@@ -2,7 +2,7 @@
 //! time a lookup needs them, native only), outline cache.
 
 use std::collections::HashMap;
-use std::sync::atomic::{AtomicU32, Ordering};
+use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex, RwLock};
 
 use kurbo::BezPath;
@@ -12,6 +12,9 @@ use skrifa::raw::FileRef;
 use skrifa::string::StringId;
 use skrifa::{GlyphId, MetadataProvider};
 
+mod user;
+pub use user::{FONT_FILE_EXTS, FontFormat, Installed, MAX_FONT_FILE_BYTES, UserFont, UserFontError, decode_font_file, is_font_file_name, sniff};
+
 /// The family used when a requested family is unknown (the UI sans).
 pub const FALLBACK_FAMILY: &str = "Source Sans 3";
 
@@ -54,6 +57,9 @@ pub struct FontFace {
     /// Semibold"): the typographic family for Regular, Bold and Italic faces, the family plus the
     /// other style words for the rest. See [`legacy_family`].
     pub legacy_family: String,
+    /// The family's names in other languages (宋体 for SimSun), from the `name` table. Lookups by
+    /// family name accept them; the font list shows them in a matching interface language.
+    pub local_names: Vec<LocalName>,
     /// usWeightClass-style weight (400 = regular).
     pub weight: f32,
     pub italic: bool,
@@ -185,6 +191,12 @@ impl FontFace {
         }
         self.skrifa().is_some_and(|f| f.charmap().map(c).is_some())
     }
+    /// Does the face carry OpenType glyph substitution (GSUB)? Complex scripts (Myanmar, Khmer,
+    /// Indic…) need it to reorder and stack; fonts with only Apple's AAT tables draw them unshaped.
+    pub fn has_layout_tables(&self) -> bool {
+        use skrifa::raw::TableProvider;
+        self.skrifa().is_some_and(|f| f.gsub().is_ok())
+    }
     /// Units per em.
     pub fn units_per_em(&self) -> f64 {
         self.upem
@@ -212,6 +224,53 @@ impl FontFace {
     pub fn glyph_for(&self, c: char) -> u32 {
         self.skrifa().and_then(|f| f.charmap().map(c)).map(|g| g.to_u32()).unwrap_or(0)
     }
+    /// Is this an East Asian (Chinese, Japanese or Korean) font? Its OS/2 code pages say so
+    /// (Shift-JIS, GB2312, Wansung, Big5, Johab), or, without them, it maps common ideographs.
+    /// Word applies such a font to East Asian text too (`w:eastAsia`).
+    pub fn is_east_asian(&self) -> bool {
+        self.skrifa().is_some_and(|f| east_asian_font(&f))
+    }
+}
+
+/// Is `f` an East Asian (Chinese, Japanese or Korean) font: do its OS/2 code pages say so
+/// (Shift-JIS, GB2312, Wansung, Big5, Johab), or, without them, does it map common ideographs?
+fn east_asian_font(f: &skrifa::FontRef<'_>) -> bool {
+    use skrifa::raw::TableProvider;
+    const CJK_CODE_PAGES: u32 = 0b1_1111 << 17;
+    match f.os2().ok().and_then(|t| t.ul_code_page_range_1()) {
+        Some(pages) if pages != 0 => pages & CJK_CODE_PAGES != 0,
+        _ => ['中', '国', '日'].iter().all(|c| f.charmap().map(*c).is_some()),
+    }
+}
+
+/// A family name in another language, from a font's `name` table.
+#[derive(Clone, Debug, PartialEq)]
+pub struct LocalName {
+    /// BCP 47 language tag, lowercase (`zh-hans`, `zh-tw`, `ja-jp`).
+    pub lang: String,
+    /// The name in that language (宋体).
+    pub name: String,
+    /// The English family name it stands for (SimSun): the face's typographic or legacy family.
+    pub english: String,
+}
+
+/// Does a `name` table language tag (`zh-Hans`, `zh-TW`, `ja-JP`) suit the interface language
+/// `ui` (`zh-hans`, `zh-hant`, `ja`)? Chinese matches by script: Simplified for mainland China and
+/// Singapore, Traditional for Taiwan, Hong Kong and Macao.
+pub fn name_language_matches(ui: &str, tag: &str) -> bool {
+    let parts = |s: &str| s.split(['-', '_']).map(str::to_ascii_lowercase).collect::<Vec<_>>();
+    let (u, t) = (parts(ui), parts(tag));
+    let (Some(up), Some(tp)) = (u.first(), t.first()) else { return false };
+    if up.is_empty() || up != tp {
+        return false;
+    }
+    if up != "zh" {
+        return true;
+    }
+    let traditional = |p: &[String]| p.iter().any(|x| matches!(x.as_str(), "hant" | "tw" | "hk" | "mo"));
+    let simplified = |p: &[String]| p.iter().any(|x| matches!(x.as_str(), "hans" | "cn" | "sg"));
+    // Plain `zh` is Simplified Chinese, as in the interface languages.
+    if traditional(&u) { traditional(&t) } else { simplified(&t) }
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -220,6 +279,9 @@ struct CatalogEntry {
     family: String,
     style: String,
     legacy: String,
+    local: Vec<LocalName>,
+    /// A Chinese, Japanese or Korean font ([`FontFace::is_east_asian`]).
+    east_asian: bool,
     path: std::path::PathBuf,
 }
 
@@ -234,6 +296,10 @@ pub struct FontDb {
     fallbacks: RwLock<FallbackCache>,
     #[cfg(not(target_arch = "wasm32"))]
     catalog: RwLock<Vec<CatalogEntry>>,
+    /// Fonts the user added at run time, and the folder they are stored in (#582).
+    user: RwLock<user::UserFonts>,
+    /// Bumped whenever user fonts are added or removed ([`FontDb::generation`]).
+    generation: AtomicU64,
     /// The folders the system font scan reads (the platform's font folders for [`FontDb::global`]).
     #[cfg_attr(target_arch = "wasm32", allow(dead_code))]
     font_dirs: Vec<std::path::PathBuf>,
@@ -247,6 +313,19 @@ pub struct FontDb {
     /// System fallback state: enabled, and characters no system font covers.
     #[cfg(not(target_arch = "wasm32"))]
     sys: Mutex<SysFallback>,
+    /// Held through a system fallback search, so searches run one at a time. Without it a search
+    /// racing another that was still loading a preferred family ("Padauk" for Myanmar) skipped
+    /// that family as already tried and loaded whatever the coverage index found first (only
+    /// Padauk Bold), so which face a character fell back to depended on thread timing.
+    #[cfg(not(target_arch = "wasm32"))]
+    searching: Mutex<()>,
+    /// The characters each installed font file maps, read the first time a fallback search
+    /// needs that file. Held through a search, so two searches never read a file twice.
+    #[cfg(not(target_arch = "wasm32"))]
+    coverage: Mutex<CoverageIndex>,
+    /// Counts the font folder scans, so the coverage index notices a rescan.
+    #[cfg(not(target_arch = "wasm32"))]
+    catalog_gen: AtomicU32,
 }
 
 #[cfg(not(target_arch = "wasm32"))]
@@ -254,6 +333,115 @@ pub struct FontDb {
 struct SysFallback {
     enabled: bool,
     misses: std::collections::HashSet<char>,
+    /// Preferred fallback families already loaded (or tried) by a fallback search.
+    tried: std::collections::HashSet<&'static str>,
+}
+
+/// Characters remembered as covered by no installed font (a cap on memory: once full the set
+/// starts over, and the coverage index answers again quickly).
+#[cfg(not(target_arch = "wasm32"))]
+const SYS_MISSES_MAX: usize = 65_536;
+
+/// Installed font files larger than this are not searched for fallback characters.
+#[cfg(not(target_arch = "wasm32"))]
+const SYS_FALLBACK_MAX_FILE: u64 = 40 << 20;
+
+/// Which characters each cataloged font file maps (#605). Before it, every distinct character no
+/// loaded font covered read and parsed every installed font file again: 500 distinct Tangut
+/// characters froze the app for most of a minute. Now each file is read once, when a search
+/// first gets to it, and later searches answer from its ranges, reading only a file that matches.
+#[cfg(not(target_arch = "wasm32"))]
+#[derive(Default)]
+struct CoverageIndex {
+    /// The catalog scan the file list was taken from (`None` until the first search).
+    generation: Option<u32>,
+    /// The cataloged font files, sorted.
+    files: Vec<IndexedFile>,
+    /// Font files read by fallback searches (each at most once to index it, once more to load it).
+    reads: usize,
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+struct IndexedFile {
+    path: std::path::PathBuf,
+    /// The code points the file's faces map, as sorted, disjoint inclusive ranges (`None` until
+    /// the file is read; empty when it can't be read or is too large).
+    ranges: Option<Box<[(u32, u32)]>>,
+    /// Loaded for a character it covers: its faces are searched as loaded fonts from then on.
+    used: bool,
+}
+
+/// Does `ranges` (sorted, disjoint, inclusive) hold `cp`?
+#[cfg(not(target_arch = "wasm32"))]
+fn ranges_hold(ranges: &[(u32, u32)], cp: u32) -> bool {
+    let i = ranges.partition_point(|r| r.1 < cp);
+    ranges.get(i).is_some_and(|r| r.0 <= cp)
+}
+
+/// The code points mapped by the faces of `data` (a font file or collection), as sorted,
+/// disjoint, inclusive ranges. Bounded however damaged the file: at most 256 faces, a budget of
+/// mappings read across them, and a cap on the ranges kept.
+#[cfg(not(target_arch = "wasm32"))]
+fn coverage_ranges(data: &[u8]) -> Box<[(u32, u32)]> {
+    const MAX_FACES: u32 = 256;
+    const MAX_MAPPINGS: usize = 4 * 0x11_0000;
+    const MAX_RANGES: usize = 1 << 17;
+    fn compact(r: &mut Vec<(u32, u32)>) {
+        r.sort_unstable();
+        let mut out: Vec<(u32, u32)> = Vec::with_capacity(r.len());
+        for &(s, e) in r.iter() {
+            match out.last_mut() {
+                Some(last) if s <= last.1.saturating_add(1) => last.1 = last.1.max(e),
+                _ => out.push((s, e)),
+            }
+        }
+        *r = out;
+    }
+    let count = match FileRef::new(data) {
+        Ok(FileRef::Font(_)) => 1,
+        Ok(FileRef::Collection(c)) => c.len().min(MAX_FACES),
+        Err(_) => 0,
+    };
+    let mut ranges: Vec<(u32, u32)> = Vec::new();
+    let mut budget = MAX_MAPPINGS;
+    'faces: for i in 0..count {
+        let Ok(f) = skrifa::FontRef::from_index(data, i) else { continue };
+        for (cp, _) in f.charmap().mappings() {
+            budget = match budget.checked_sub(1) {
+                Some(b) => b,
+                None => break 'faces,
+            };
+            match ranges.last_mut() {
+                Some(last) if last.1.checked_add(1) == Some(cp) => last.1 = cp,
+                Some(last) if last.0 <= cp && cp <= last.1 => {}
+                _ => {
+                    if ranges.len() >= MAX_RANGES {
+                        compact(&mut ranges);
+                        if ranges.len() >= MAX_RANGES {
+                            break 'faces;
+                        }
+                    }
+                    ranges.push((cp, cp));
+                }
+            }
+        }
+    }
+    compact(&mut ranges);
+    ranges.into_boxed_slice()
+}
+
+/// An installed font file's bytes, `None` when it can't be read or is larger than
+/// [`SYS_FALLBACK_MAX_FILE`] (also when it grew past that since it was cataloged).
+#[cfg(not(target_arch = "wasm32"))]
+fn read_fallback_file(path: &std::path::Path) -> Option<Vec<u8>> {
+    use std::io::Read;
+    let file = std::fs::File::open(path).ok()?;
+    if file.metadata().ok()?.len() > SYS_FALLBACK_MAX_FILE {
+        return None;
+    }
+    let mut data = Vec::new();
+    file.take(SYS_FALLBACK_MAX_FILE + 1).read_to_end(&mut data).ok()?;
+    (data.len() as u64 <= SYS_FALLBACK_MAX_FILE).then_some(data)
 }
 
 /// Families preferred for right-to-left scripts (Persian, Arabic, Urdu, Hebrew) when the
@@ -327,6 +515,35 @@ fn name(font: &skrifa::FontRef<'_>, ids: &[StringId]) -> Option<String> {
     ids.iter().find_map(|id| font.localized_strings(*id).english_or_first().map(|s| s.to_string()).filter(|s| !s.is_empty()))
 }
 
+/// The family's names in other languages: localized typographic family names (name ID 16) stand
+/// for `family`, localized legacy family names (name ID 1) for `id1` (or for `family` when the
+/// font has no typographic names). Bounded: a damaged font can list any number of records.
+fn local_names(f: &skrifa::FontRef<'_>, family: &str, id1: Option<&str>) -> Vec<LocalName> {
+    const MAX_NAMES: usize = 64;
+    const MAX_CHARS: usize = 128;
+    let typographic = f.localized_strings(StringId::TYPOGRAPHIC_FAMILY_NAME).next().is_some();
+    let legacy = if typographic { id1 } else { Some(family) };
+    let mut out: Vec<LocalName> = Vec::new();
+    for (id, english) in [(StringId::TYPOGRAPHIC_FAMILY_NAME, Some(family)), (StringId::FAMILY_NAME, legacy)] {
+        let Some(english) = english else { continue };
+        for s in f.localized_strings(id) {
+            let Some(lang) = s.language().map(str::to_ascii_lowercase) else { continue };
+            if lang == "en" || lang.starts_with("en-") {
+                continue;
+            }
+            let name: String = s.chars().take(MAX_CHARS).collect::<String>().trim().to_string();
+            if name.is_empty() || name.eq_ignore_ascii_case(english) || out.iter().any(|n| n.lang == lang && n.name == name) {
+                continue;
+            }
+            if out.len() >= MAX_NAMES {
+                return out;
+            }
+            out.push(LocalName { lang, name, english: english.to_string() });
+        }
+    }
+    out
+}
+
 /// A face's family and style names (the default instance's style for a variable font), and its
 /// legacy family name (name ID 1) when it has one.
 pub(crate) fn face_names(f: &skrifa::FontRef<'_>) -> Option<(String, String, Option<String>)> {
@@ -345,11 +562,12 @@ pub(crate) fn legacy_family(family: &str, style: &str) -> String {
     if extra.is_empty() { family.to_string() } else { format!("{family} {}", extra.join(" ")) }
 }
 
-/// (family, style, legacy family) of every face in the font file at `path`, reading only its
-/// table directories and `name` and `fvar` tables: a scan opens hundreds of font files, many of
-/// them megabytes long. A variable font yields one entry per named instance, as it does loaded.
+/// The names of every face in the font file at `path`, reading only its table directories and
+/// `name` and `fvar` tables: a scan opens hundreds of font files, many of them megabytes long
+/// (CJK collections run to 20 MB and more). A variable font yields one entry per named instance,
+/// as it does loaded.
 #[cfg(not(target_arch = "wasm32"))]
-fn file_face_names(path: &std::path::Path) -> Vec<(String, String, String)> {
+fn file_face_names(path: &std::path::Path) -> Vec<Found> {
     use std::io::{Read, Seek, SeekFrom};
     /// Caps on what a (possibly damaged) file can make the scan read.
     const MAX_FACES: u32 = 256;
@@ -385,13 +603,13 @@ fn file_face_names(path: &std::path::Path) -> Vec<(String, String, String)> {
                 read_at(offset.into(), len as usize)
             };
             let name = table(b"name")?;
-            // Variable fonts: the named instances.
-            let mut tables: Vec<([u8; 4], Vec<u8>)> = table(b"fvar").map(|t| (*b"fvar", t)).into_iter().collect();
+            // Variable fonts: the named instances; OS/2: the code pages (East Asian fonts).
+            let mut tables: Vec<([u8; 4], Vec<u8>)> = table(b"OS/2").map(|t| (*b"OS/2", t)).into_iter().collect();
+            tables.extend(table(b"fvar").map(|t| (*b"fvar", t)));
             tables.push((*b"name", name));
             // A font holding just those tables, to read them as the font itself would.
             let font = mini_font(&tables);
-            let faces = font_faces(&skrifa::FontRef::new(&font).ok()?, 0);
-            Some(faces.into_iter().map(|f| (f.family, f.style, f.legacy)).collect::<Vec<_>>())
+            Some(font_faces(&skrifa::FontRef::new(&font).ok()?, 0))
         })
         .flatten()
         .collect()
@@ -434,8 +652,9 @@ pub fn system_font_dirs() -> Vec<std::path::PathBuf> {
         if let Some(h) = &home {
             dirs.push(h.join("Library/Fonts"));
         }
-        // Fonts macOS ships as assets (PingFang, Yu Mincho, …): com_apple_MobileAsset_Font<N>.
-        for parent in ["/System/Library/AssetsV2", "/System/Library/AssetsV2/PreinstalledAssetsV2/InstallWithOs"] {
+        // Fonts macOS ships as assets (PingFang, Yu Mincho, …): com_apple_MobileAsset_Font<N>
+        // (`Assets` before macOS 11, `AssetsV2` since).
+        for parent in ["/System/Library/AssetsV2", "/System/Library/AssetsV2/PreinstalledAssetsV2/InstallWithOs", "/System/Library/Assets"] {
             let Ok(entries) = std::fs::read_dir(parent) else { continue };
             for e in entries.flatten() {
                 if e.file_name().to_string_lossy().starts_with("com_apple_MobileAsset_Font") {
@@ -467,6 +686,11 @@ struct Found {
     style: String,
     /// The legacy family name ([`FontFace::legacy_family`]).
     legacy: String,
+    /// The family's names in other languages ([`FontFace::local_names`]).
+    local: Vec<LocalName>,
+    /// A Chinese, Japanese or Korean font ([`FontFace::is_east_asian`]); the scan's catalog keeps it.
+    #[cfg_attr(target_arch = "wasm32", allow(dead_code))]
+    east_asian: bool,
     /// Variable fonts: the named instance's axis settings.
     coords: Vec<([u8; 4], f32)>,
 }
@@ -475,6 +699,8 @@ struct Found {
 /// (InDesign lists them as styles), otherwise the font itself.
 fn font_faces(f: &skrifa::FontRef<'_>, index: u32) -> Vec<Found> {
     let Some((family, style, id1)) = face_names(f) else { return vec![] };
+    let local = local_names(f, &family, id1.as_deref());
+    let east_asian = east_asian_font(f);
     let axes = f.axes();
     let mut named: Vec<Found> = Vec::new();
     for ni in f.named_instances().iter() {
@@ -485,13 +711,15 @@ fn font_faces(f: &skrifa::FontRef<'_>, index: u32) -> Vec<Found> {
         let coords: Vec<([u8; 4], f32)> = axes.iter().zip(ni.user_coords()).map(|(a, v)| (a.tag().to_be_bytes(), v)).collect();
         // Name ID 1 names the default instance only.
         let legacy = legacy_family(&family, &style);
-        named.push(Found { index, family: family.clone(), style, legacy, coords });
+        // Name ID 1 names the default instance only: keep the names of the whole family.
+        let local = local.iter().filter(|n| n.english.eq_ignore_ascii_case(&family)).cloned().collect();
+        named.push(Found { index, family: family.clone(), style, legacy, local, east_asian, coords });
     }
     if !named.is_empty() {
         return named;
     }
     let legacy = id1.filter(|n| !n.eq_ignore_ascii_case(&family)).unwrap_or_else(|| legacy_family(&family, &style));
-    vec![Found { index, family, style, legacy, coords: Vec::new() }]
+    vec![Found { index, family, style, legacy, local, east_asian, coords: Vec::new() }]
 }
 
 /// Parse every face in `data` (a font file or collection); a variable font yields one face per
@@ -544,6 +772,7 @@ fn make_face(bytes: FontBytes, index: u32, family: String, style: String, legacy
         family,
         style,
         legacy_family,
+        local_names: Vec::new(),
         weight,
         italic,
         upem: m.units_per_em.max(1) as f64,
@@ -605,8 +834,9 @@ impl FontDb {
         let craft = crate::japanese_document_fonts().into_iter().map(|f| f.bytes);
         for data in BUNDLED.iter().copied().chain(craft) {
             for f in enumerate_faces(data) {
-                if let Some(f) = make_face(FontBytes::Static(data), f.index, f.family, f.style, f.legacy, f.coords) {
-                    faces.push(Arc::new(f));
+                if let Some(mut face) = make_face(FontBytes::Static(data), f.index, f.family, f.style, f.legacy, f.coords) {
+                    face.local_names = f.local;
+                    faces.push(Arc::new(face));
                 }
             }
         }
@@ -616,6 +846,8 @@ impl FontDb {
             fallbacks: RwLock::new(FallbackCache::default()),
             #[cfg(not(target_arch = "wasm32"))]
             catalog: RwLock::new(Vec::new()),
+            user: RwLock::new(user::UserFonts::default()),
+            generation: AtomicU64::new(0),
             font_dirs,
             #[cfg(not(target_arch = "wasm32"))]
             cataloged: std::sync::OnceLock::new(),
@@ -623,6 +855,12 @@ impl FontDb {
             loading: Mutex::new(()),
             #[cfg(not(target_arch = "wasm32"))]
             sys: Mutex::new(SysFallback { enabled: true, ..Default::default() }),
+            #[cfg(not(target_arch = "wasm32"))]
+            searching: Mutex::new(()),
+            #[cfg(not(target_arch = "wasm32"))]
+            coverage: Mutex::new(CoverageIndex::default()),
+            #[cfg(not(target_arch = "wasm32"))]
+            catalog_gen: AtomicU32::new(0),
         }
     }
 
@@ -670,9 +908,76 @@ impl FontDb {
         v
     }
 
+    /// The installed Chinese, Japanese and Korean families (English names), for the Font dialog's
+    /// Asian text font list.
+    pub fn east_asian_families(&self) -> Vec<String> {
+        let mut v: Vec<String> = self.read_faces().iter().filter(|f| f.is_east_asian()).map(|f| f.family.clone()).collect();
+        #[cfg(not(target_arch = "wasm32"))]
+        v.extend(self.read_catalog().iter().filter(|c| c.east_asian).map(|c| c.family.clone()));
+        v.sort_by_key(|a| a.to_lowercase());
+        v.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
+        v
+    }
+
+    /// Every family's name in the interface language `lang` (`zh-hans`, `zh-hant`, `ja`…), as
+    /// (English name, localized name) pairs: SimSun is 宋体 in Simplified Chinese. Families without
+    /// a name in that language are left out.
+    pub fn localized_names(&self, lang: &str) -> Vec<(String, String)> {
+        let mut v: Vec<(String, String)> = Vec::new();
+        let mut add = |names: &[LocalName]| {
+            for n in names.iter().filter(|n| name_language_matches(lang, &n.lang)) {
+                if !v.iter().any(|(e, _)| e.eq_ignore_ascii_case(&n.english)) {
+                    v.push((n.english.clone(), n.name.clone()));
+                }
+            }
+        };
+        for f in self.read_faces().iter() {
+            add(&f.local_names);
+        }
+        #[cfg(not(target_arch = "wasm32"))]
+        for c in self.read_catalog().iter() {
+            add(&c.local);
+        }
+        v
+    }
+
+    /// [`FontDb::families`] as the font list shows them in the interface language `lang`: each
+    /// family that has a name in that language by that name (宋体, 微软雅黑 in Simplified Chinese),
+    /// the others by their English names. Lookups accept either name.
+    pub fn families_in(&self, lang: &str) -> Vec<String> {
+        let local: HashMap<String, String> = self.localized_names(lang).into_iter().map(|(e, l)| (e.to_lowercase(), l)).collect();
+        let mut v: Vec<String> = self.families().into_iter().map(|f| local.get(&f.to_lowercase()).cloned().unwrap_or(f)).collect();
+        v.sort_by_key(|a| a.to_lowercase());
+        v.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
+        v
+    }
+
+    /// The English family a localized family name stands for (宋体 → SimSun), when no face has
+    /// `family` as its English name. `None` for names no font has.
+    pub fn english_family(&self, family: &str) -> Option<String> {
+        let hit = |names: &[LocalName]| names.iter().find(|n| n.name.eq_ignore_ascii_case(family)).map(|n| n.english.clone());
+        if let Some(e) = self.read_faces().iter().find_map(|f| hit(&f.local_names)) {
+            return Some(e);
+        }
+        #[cfg(not(target_arch = "wasm32"))]
+        if let Some(e) = self.read_catalog().iter().find_map(|c| hit(&c.local)) {
+            return Some(e);
+        }
+        None
+    }
+
     /// Style names available for `family` (Regular first, then by weight). For a legacy family
-    /// name ("Roboto Light"), the styles of the faces it names ("Light", "Light Italic").
+    /// name ("Roboto Light"), the styles of the faces it names ("Light", "Light Italic"); for a
+    /// localized name (宋体), those of the family it names.
     pub fn styles(&self, family: &str) -> Vec<String> {
+        let v = self.styles_named(family);
+        match self.english_family(family) {
+            Some(en) if v.is_empty() => self.styles_named(&en),
+            _ => v,
+        }
+    }
+
+    fn styles_named(&self, family: &str) -> Vec<String> {
         let mut v: Vec<(bool, f32, String)> = Vec::new();
         for legacy in [false, true] {
             let named = |typographic: &str, legacy_name: &str| (if legacy { legacy_name } else { typographic }).eq_ignore_ascii_case(family);
@@ -712,8 +1017,9 @@ impl FontDb {
         for bytes in files {
             let data = Arc::new(bytes);
             for f in enumerate_faces(&data) {
-                if let Some(f) = make_face(FontBytes::Owned(data.clone()), f.index, f.family, f.style, f.legacy, f.coords) {
-                    new.push(Arc::new(f));
+                if let Some(mut face) = make_face(FontBytes::Owned(data.clone()), f.index, f.family, f.style, f.legacy, f.coords) {
+                    face.local_names = f.local;
+                    new.push(Arc::new(face));
                 }
             }
         }
@@ -780,14 +1086,22 @@ impl FontDb {
                 if !matches!(ext.as_deref(), Some("ttf" | "otf" | "ttc" | "otc")) {
                     continue;
                 }
-                for (family, style, legacy) in file_face_names(&p) {
-                    found.push(CatalogEntry { family, style, legacy, path: p.clone() });
+                for f in file_face_names(&p) {
+                    found.push(CatalogEntry {
+                        family: f.family,
+                        style: f.style,
+                        legacy: f.legacy,
+                        local: f.local,
+                        east_asian: f.east_asian,
+                        path: p.clone(),
+                    });
                 }
             }
         }
         let n = found.len();
         log::debug!("cataloged {n} system font faces");
         *self.catalog.write().unwrap_or_else(|e| e.into_inner()) = found;
+        self.catalog_gen.fetch_add(1, Ordering::AcqRel);
         n
     }
 
@@ -833,13 +1147,27 @@ impl FontDb {
                 return f;
             }
         }
+        // A localized family name (宋体 → SimSun).
+        if let Some(en) = self.english_family(family).filter(|en| !en.eq_ignore_ascii_case(family)) {
+            if let Some(f) = self.find(&en, style) {
+                return f;
+            }
+            #[cfg(not(target_arch = "wasm32"))]
+            {
+                self.load_cataloged(&en);
+                if let Some(f) = self.find(&en, style) {
+                    return f;
+                }
+            }
+        }
         self.find(FALLBACK_FAMILY, style)
             .or_else(|| self.find(FALLBACK_FAMILY, "Regular"))
             .or_else(|| self.read_faces().first().cloned())
             .unwrap_or_else(last_resort_face)
     }
 
-    /// Is `family` available (loaded, or installed on the system)?
+    /// Is `family` available (loaded, or installed on the system)? English and localized family
+    /// names both count.
     pub fn has_family(&self, family: &str) -> bool {
         if self.is_loaded(family) {
             return true;
@@ -848,7 +1176,7 @@ impl FontDb {
         if self.read_catalog().iter().any(|c| c.family.eq_ignore_ascii_case(family) || c.legacy.eq_ignore_ascii_case(family)) {
             return true;
         }
-        false
+        self.english_family(family).is_some()
     }
 
     /// Is a face named `family` (its typographic or legacy family) loaded?
@@ -891,7 +1219,8 @@ impl FontDb {
                 None => coords.push((tag, v)),
             }
         }
-        let f = make_face(base.bytes.clone(), base.index, base.family.clone(), style.to_string(), base.legacy_family.clone(), coords)?;
+        let mut f = make_face(base.bytes.clone(), base.index, base.family.clone(), style.to_string(), base.legacy_family.clone(), coords)?;
+        f.local_names = base.local_names.clone();
         let f = Arc::new(f);
         self.faces.write().unwrap_or_else(|e| e.into_inner()).push(f.clone());
         Some(f)
@@ -964,9 +1293,13 @@ impl FontDb {
                 return hit.clone();
             }
         }
-        let found = self.search_fallback(c, exclude);
-        // Keyed by the face count after the search (a system fallback may have loaded fonts).
-        let n = self.read_faces().len();
+        let (found, n) = self.search_fallback(c, exclude);
+        // Keyed by the face count the answer was chosen from (a system fallback may have loaded
+        // fonts, and another thread may have loaded more since: an answer from before that load
+        // is returned but not cached under the new count).
+        if n != self.read_faces().len() {
+            return found;
+        }
         let mut cache = self.fallbacks.write().unwrap_or_else(|e| e.into_inner());
         if cache.faces != n || cache.map.len() >= FALLBACK_CACHE_MAX {
             cache.map.clear();
@@ -976,17 +1309,36 @@ impl FontDb {
         found
     }
 
-    fn search_fallback(&self, c: char, exclude: u32) -> Option<Arc<FontFace>> {
-        self.loaded_fallback(c, exclude).or_else(|| {
-            #[cfg(not(target_arch = "wasm32"))]
-            if self.system_fallback(c) {
-                return self.loaded_fallback(c, exclude);
-            }
-            None
-        })
+    /// The fallback face for `c`, and the number of loaded faces it was chosen from.
+    fn search_fallback(&self, c: char, exclude: u32) -> (Option<Arc<FontFace>>, usize) {
+        let (found, n) = self.loaded_fallback(c, exclude);
+        if found.is_some() {
+            return (found, n);
+        }
+        self.system_search(c, exclude)
     }
 
-    fn loaded_fallback(&self, c: char, exclude: u32) -> Option<Arc<FontFace>> {
+    /// [`Self::search_fallback`] when no loaded face covers `c`: load a system font that does,
+    /// one search at a time.
+    #[cfg(not(target_arch = "wasm32"))]
+    fn system_search(&self, c: char, exclude: u32) -> (Option<Arc<FontFace>>, usize) {
+        let _searching = self.searching.lock().unwrap_or_else(|e| e.into_inner());
+        // A search that held the lock first may have loaded a font covering `c`: choose among the
+        // loaded faces again before loading more.
+        let (found, n) = self.loaded_fallback(c, exclude);
+        if found.is_none() && self.system_fallback(c) {
+            return self.loaded_fallback(c, exclude);
+        }
+        (found, n)
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    fn system_search(&self, _c: char, _exclude: u32) -> (Option<Arc<FontFace>>, usize) {
+        (None, self.read_faces().len())
+    }
+
+    /// The best loaded face covering `c`, and the number of loaded faces it was chosen from.
+    fn loaded_fallback(&self, c: char, exclude: u32) -> (Option<Arc<FontFace>>, usize) {
         let faces = self.read_faces();
         let mut order: Vec<&Arc<FontFace>> = faces.iter().filter(|f| f.id != exclude).collect();
         // Right-to-left letters prefer a font made for the script, so a word isn't split across
@@ -998,12 +1350,17 @@ impl FontDb {
                 0
             }
         };
-        order.sort_by_key(|f| (rank(f), !f.family.eq_ignore_ascii_case(FALLBACK_FAMILY), f.italic, (f.weight - 400.0).abs() as i32));
-        order.into_iter().find(|f| f.covers(c)).cloned()
+        // Complex scripts (Myanmar, Khmer, Indic…): a font with OpenType layout tables, preferring
+        // the script's own families, so syllables reorder and stack (#604).
+        let complex = crate::needs_layout_tables(c);
+        let shaping = |f: &FontFace| if complex { (!f.has_layout_tables(), crate::fallback_rank(c, &f.family)) } else { (false, 0) };
+        order.sort_by_key(|f| (rank(f), shaping(f), !f.family.eq_ignore_ascii_case(FALLBACK_FAMILY), f.italic, (f.weight - 400.0).abs() as i32));
+        (order.into_iter().find(|f| f.covers(c)).cloned(), faces.len())
     }
 
     /// Load a system font covering `c` (preferred fallback families first, then any cataloged
-    /// file under 40 MB). Returns true if one was loaded. Misses are remembered.
+    /// file under 40 MB, found through the coverage index). Returns true if one was loaded.
+    /// Misses are remembered.
     #[cfg(not(target_arch = "wasm32"))]
     fn system_fallback(&self, c: char) -> bool {
         if c.is_control() || c.is_whitespace() {
@@ -1019,28 +1376,77 @@ impl FontDb {
         let cataloged: Vec<String> = self.read_catalog().iter().map(|e| e.family.clone()).collect();
         let rtl = crate::is_rtl(c) || arabic_block(c);
         let preferred = RTL_FALLBACKS.iter().filter(|_| rtl);
-        for fam in preferred.chain(SYSTEM_FALLBACKS.iter()) {
-            if !self.is_loaded(fam) && cataloged.iter().any(|f| f.eq_ignore_ascii_case(fam)) {
-                self.load_cataloged(fam);
-                if covered(self) {
-                    return true;
-                }
-            }
-        }
-        let mut paths: Vec<std::path::PathBuf> = self.catalog.read().unwrap_or_else(|e| e.into_inner()).iter().map(|e| e.path.clone()).collect();
-        paths.sort();
-        paths.dedup();
-        for p in paths {
-            if std::fs::metadata(&p).map(|m| m.len() > 40 << 20).unwrap_or(true) {
+        for fam in crate::script_fallbacks(c).iter().chain(preferred).chain(SYSTEM_FALLBACKS.iter()) {
+            // Each family is tried once: one that fails to load isn't read again per character.
+            if self.is_loaded(fam) || !cataloged.iter().any(|f| f.eq_ignore_ascii_case(fam)) {
                 continue;
             }
-            let Ok(data) = std::fs::read(&p) else { continue };
-            let hit = enumerate_faces(&data).iter().any(|f| skrifa::FontRef::from_index(&data, f.index).is_ok_and(|f| f.charmap().map(c).is_some()));
-            if hit && self.add_font(data) > 0 && covered(self) {
+            if !self.sys.lock().unwrap_or_else(|e| e.into_inner()).tried.insert(fam) {
+                continue;
+            }
+            self.load_cataloged(fam);
+            if covered(self) {
+                return true;
+            }
+        }
+        if self.indexed_fallback(c) {
+            return true;
+        }
+        let mut sys = self.sys.lock().unwrap_or_else(|e| e.into_inner());
+        if sys.misses.len() >= SYS_MISSES_MAX {
+            sys.misses.clear();
+        }
+        sys.misses.insert(c);
+        false
+    }
+
+    /// Load the first cataloged font file (in path order) that maps `c`, reading each file not
+    /// yet indexed as the search reaches it. Returns whether a loaded face now covers `c`.
+    #[cfg(not(target_arch = "wasm32"))]
+    fn indexed_fallback(&self, c: char) -> bool {
+        let cp = u32::from(c);
+        let mut index = self.coverage.lock().unwrap_or_else(|e| e.into_inner());
+        let generation = self.catalog_gen.load(Ordering::Acquire);
+        if index.generation != Some(generation) {
+            // A new scan (or the first search): keep what is known of files still installed.
+            let mut known: HashMap<std::path::PathBuf, IndexedFile> =
+                std::mem::take(&mut index.files).into_iter().map(|f| (f.path.clone(), f)).collect();
+            let mut paths: Vec<std::path::PathBuf> = self.catalog.read().unwrap_or_else(|e| e.into_inner()).iter().map(|e| e.path.clone()).collect();
+            paths.sort();
+            paths.dedup();
+            index.files = paths.into_iter().map(|path| known.remove(&path).unwrap_or(IndexedFile { path, ranges: None, used: false })).collect();
+            index.generation = Some(generation);
+        }
+        let CoverageIndex { files, reads, .. } = &mut *index;
+        for file in files.iter_mut().filter(|f| !f.used) {
+            let mut data = None;
+            match &file.ranges {
+                Some(r) if !ranges_hold(r, cp) => continue,
+                Some(_) => {}
+                None => {
+                    *reads += 1;
+                    data = read_fallback_file(&file.path);
+                    let ranges = data.as_deref().map(coverage_ranges).unwrap_or_default();
+                    let hit = ranges_hold(&ranges, cp);
+                    file.ranges = Some(ranges);
+                    if !hit {
+                        continue;
+                    }
+                }
+            }
+            // The file maps `c`: load it (once; its faces are loaded fonts from now on).
+            file.used = true;
+            if data.is_none() {
+                *reads += 1;
+                data = read_fallback_file(&file.path);
+            }
+            if let Some(data) = data
+                && self.add_font(data) > 0
+                && self.read_faces().iter().any(|f| f.covers(c))
+            {
                 return true;
             }
         }
-        self.sys.lock().unwrap_or_else(|e| e.into_inner()).misses.insert(c);
         false
     }
 
diff --git a/crates/fonts/src/fontdb/user.rs b/crates/fonts/src/fontdb/user.rs
new file mode 100644
index 0000000000..ff9cee66eb
--- /dev/null
+++ b/crates/fonts/src/fontdb/user.rs
@@ -0,0 +1,699 @@
+//! Fonts an end user adds at run time, without rebuilding (#582).
+//!
+//! The bundled faces (and the system fonts) stay the baseline: a user font only adds faces, never
+//! replaces one (a face whose family and style are already loaded is skipped), so documents that
+//! don't name it keep their metrics. A file is checked before anything is added: its size is
+//! capped, WOFF and WOFF2 are unwrapped, and every face must parse and map characters.
+//!
+//! Desktop: [`FontDb::load_user_fonts`] names a folder (the app's `fonts` folder); the fonts there
+//! load at start-up and each font added later is copied there (unwrapped from WOFF/WOFF2). Without
+//! a folder (the web, tests, `WORDCRAFT_NO_PREFS`) added fonts last for the session; the web
+//! shell keeps them in the browser itself.
+
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::sync::atomic::Ordering;
+
+use skrifa::MetadataProvider;
+use skrifa::raw::FileRef;
+
+use super::{FontBytes, FontDb, enumerate_faces, make_face};
+
+/// Largest font file accepted (as given: TTF, OTF, TTC, WOFF or WOFF2).
+pub const MAX_FONT_FILE_BYTES: usize = 50 << 20;
+/// Largest font a WOFF/WOFF2 file may unwrap to.
+const MAX_DECODED_BYTES: usize = 128 << 20;
+/// Most faces one file may add (collections, variable fonts' named instances).
+const MAX_FACES_PER_FILE: usize = 256;
+/// Most user fonts at once.
+const MAX_USER_FONTS: usize = 1000;
+/// File extensions [`FontDb::load_user_fonts`] reads (fonts are stored unwrapped).
+const STORED_EXTS: &[&str] = &["ttf", "otf", "ttc", "otc"];
+/// Extensions a font file the user picks or drops may have.
+pub const FONT_FILE_EXTS: &[&str] = &["ttf", "otf", "ttc", "otc", "woff", "woff2"];
+
+/// Is `name` (a file name or path) named like a font file?
+pub fn is_font_file_name(name: &str) -> bool {
+    let ext = name.rsplit_once('.').map(|(_, e)| e.to_ascii_lowercase());
+    ext.is_some_and(|e| FONT_FILE_EXTS.contains(&e.as_str()))
+}
+
+/// Why a font couldn't be added or removed.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum UserFontError {
+    Empty,
+    TooLarge {
+        bytes: usize,
+    },
+    /// Not a font file this reads (TrueType, OpenType, collections, WOFF, WOFF2).
+    NotAFont,
+    /// A WOFF/WOFF2 file that couldn't be unwrapped.
+    BadWebFont(String),
+    /// A font file that doesn't parse, or has no usable face.
+    Unusable(String),
+    /// Every face in the file is already available.
+    AlreadyAvailable(Vec<String>),
+    TooMany,
+    /// The family isn't one the user added (bundled and system fonts can't be removed).
+    NotUserFont(String),
+}
+
+impl std::fmt::Display for UserFontError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            UserFontError::Empty => write!(f, "the font file is empty"),
+            UserFontError::TooLarge { bytes } => {
+                write!(f, "the font file is too large ({} MB; at most {} MB)", bytes.div_ceil(1 << 20), MAX_FONT_FILE_BYTES >> 20)
+            }
+            UserFontError::NotAFont => write!(f, "not a font file (TrueType, OpenType, TTC, WOFF or WOFF2)"),
+            UserFontError::BadWebFont(e) => write!(f, "the web font couldn't be read: {e}"),
+            UserFontError::Unusable(e) => write!(f, "the font couldn't be read: {e}"),
+            UserFontError::AlreadyAvailable(families) => write!(f, "already available: {}", families.join(", ")),
+            UserFontError::TooMany => write!(f, "too many added fonts (at most {MAX_USER_FONTS}); remove some first"),
+            UserFontError::NotUserFont(family) => write!(f, "{family:?} isn't a font you added"),
+        }
+    }
+}
+
+impl std::error::Error for UserFontError {}
+
+/// A font file the user added.
+#[derive(Clone, Debug, PartialEq)]
+pub struct UserFont {
+    /// Its file name in the user font folder (unique among the user fonts), also the key the web
+    /// shell stores it under.
+    pub file: String,
+    /// The faces it added: (typographic family, style).
+    pub faces: Vec<(String, String)>,
+    /// Where it is stored (desktop); `None` when it lasts for the session only.
+    pub path: Option<PathBuf>,
+    face_ids: Vec<u32>,
+}
+
+impl UserFont {
+    /// The families it added (typographic names, in file order, each once).
+    pub fn families(&self) -> Vec<String> {
+        let mut v: Vec<String> = Vec::new();
+        for (family, _) in &self.faces {
+            if !v.iter().any(|f| f.eq_ignore_ascii_case(family)) {
+                v.push(family.clone());
+            }
+        }
+        v
+    }
+}
+
+/// What [`FontDb::install_font`] did.
+#[derive(Clone, Debug, PartialEq)]
+pub struct Installed {
+    pub font: UserFont,
+    /// The font was added for this session but couldn't be stored for the next one.
+    pub warning: Option<String>,
+}
+
+#[derive(Default)]
+pub(super) struct UserFonts {
+    fonts: Vec<UserFont>,
+    dir: Option<PathBuf>,
+}
+
+/// The kind of font file `bytes` holds, from its signature.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum FontFormat {
+    TrueType,
+    OpenType,
+    Collection,
+    Woff,
+    Woff2,
+}
+
+pub fn sniff(bytes: &[u8]) -> Option<FontFormat> {
+    match bytes.get(..4)? {
+        [0, 1, 0, 0] | b"true" | b"typ1" => Some(FontFormat::TrueType),
+        b"OTTO" => Some(FontFormat::OpenType),
+        b"ttcf" => Some(FontFormat::Collection),
+        b"wOFF" => Some(FontFormat::Woff),
+        b"wOF2" => Some(FontFormat::Woff2),
+        _ => None,
+    }
+}
+
+/// The font file in `bytes` as plain OpenType (TTF/OTF/TTC) bytes: WOFF and WOFF2 are unwrapped.
+/// Checks the size and the signature only; [`FontDb::install_font`] checks the faces.
+pub fn decode_font_file(bytes: &[u8]) -> Result<Vec<u8>, UserFontError> {
+    if bytes.is_empty() {
+        return Err(UserFontError::Empty);
+    }
+    if bytes.len() > MAX_FONT_FILE_BYTES {
+        return Err(UserFontError::TooLarge { bytes: bytes.len() });
+    }
+    let decoded = match sniff(bytes).ok_or(UserFontError::NotAFont)? {
+        FontFormat::TrueType | FontFormat::OpenType | FontFormat::Collection => return Ok(bytes.to_vec()),
+        FontFormat::Woff => unwrap_web_font(|| wuff::decompress_woff1(bytes))?,
+        FontFormat::Woff2 => unwrap_web_font(|| wuff::decompress_woff2(bytes))?,
+    };
+    if decoded.len() > MAX_DECODED_BYTES {
+        return Err(UserFontError::TooLarge { bytes: decoded.len() });
+    }
+    match sniff(&decoded) {
+        Some(FontFormat::TrueType | FontFormat::OpenType | FontFormat::Collection) => Ok(decoded),
+        _ => Err(UserFontError::BadWebFont("it doesn't hold a TrueType or OpenType font".into())),
+    }
+}
+
+/// Run a WOFF/WOFF2 decoder. The decoder checks its input, but it is third-party code reading
+/// hostile bytes: a panic in it is caught (native) and reported as a damaged file.
+fn unwrap_web_font(decode: impl FnOnce() -> Result<Vec<u8>, wuff::WuffErr>) -> Result<Vec<u8>, UserFontError> {
+    match std::panic::catch_unwind(std::panic::AssertUnwindSafe(decode)) {
+        Ok(Ok(v)) => Ok(v),
+        Ok(Err(e)) => Err(UserFontError::BadWebFont(format!("{e:?}"))),
+        Err(_) => Err(UserFontError::BadWebFont("damaged file".into())),
+    }
+}
+
+/// A file name for a user font from the name it came with: letters, digits, spaces, `-` and `_`
+/// of its stem (others become `_`, at most 64), and the extension of its unwrapped format.
+fn stored_name(name: &str, sfnt: &[u8]) -> String {
+    // The last component, whichever separator the name came with.
+    let base = name.rsplit(['/', '\\']).next().unwrap_or(name);
+    let stem = base.rsplit_once('.').map(|(s, _)| s).unwrap_or(base);
+    let mut clean: String = stem.chars().take(64).map(|c| if c.is_alphanumeric() || matches!(c, ' ' | '-' | '_') { c } else { '_' }).collect();
+    clean = clean.trim().to_string();
+    if clean.is_empty() || clean.starts_with('-') {
+        clean = format!("font{clean}");
+    }
+    let ext = match sniff(sfnt) {
+        Some(FontFormat::OpenType) => "otf",
+        Some(FontFormat::Collection) => "ttc",
+        _ => "ttf",
+    };
+    format!("{clean}.{ext}")
+}
+
+impl FontDb {
+    /// A counter that changes whenever user fonts are added or removed: a UI caching the font
+    /// list or a layout redraws when it moves.
+    pub fn generation(&self) -> u64 {
+        self.generation.load(Ordering::Acquire)
+    }
+
+    fn read_user(&self) -> std::sync::RwLockReadGuard<'_, UserFonts> {
+        self.user.read().unwrap_or_else(|e| e.into_inner())
+    }
+
+    fn write_user(&self) -> std::sync::RwLockWriteGuard<'_, UserFonts> {
+        self.user.write().unwrap_or_else(|e| e.into_inner())
+    }
+
+    /// The fonts the user added, in the order added.
+    pub fn user_fonts(&self) -> Vec<UserFont> {
+        self.read_user().fonts.clone()
+    }
+
+    /// The folder user fonts are stored in, if any ([`FontDb::load_user_fonts`]).
+    pub fn user_font_dir(&self) -> Option<PathBuf> {
+        self.read_user().dir.clone()
+    }
+
+    /// Add the font file `bytes` (TTF, OTF, TTC, WOFF or WOFF2) named `name` (its file name, for
+    /// the stored copy). Every face is checked first; faces whose family and style are already
+    /// available are skipped (the bundled baseline is never replaced). With a user font folder the
+    /// font is stored there too, for the next start.
+    pub fn install_font(&self, name: &str, bytes: &[u8]) -> Result<Installed, UserFontError> {
+        let sfnt = decode_font_file(bytes)?;
+        let mut font = self.add_user_faces(name, sfnt.clone(), None)?;
+        let warning = match self.user_font_dir() {
+            Some(dir) => match write_unique(&dir, &font.file, &sfnt) {
+                Ok(path) => {
+                    font.file = path.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or(font.file);
+                    font.path = Some(path);
+                    None
+                }
+                Err(e) => {
+                    log::warn!("couldn't store the font {name} in {}: {e}", dir.display());
+                    Some(format!("added for this session only: couldn't store it in {}: {e}", dir.display()))
+                }
+            },
+            None => None,
+        };
+        if let Some(f) = self.write_user().fonts.iter_mut().find(|f| f.face_ids == font.face_ids) {
+            f.file.clone_from(&font.file);
+            f.path.clone_from(&font.path);
+        }
+        Ok(Installed { font, warning })
+    }
+
+    /// Check the faces in `sfnt` and add the new ones, recording them as a user font.
+    fn add_user_faces(&self, name: &str, sfnt: Vec<u8>, path: Option<PathBuf>) -> Result<UserFont, UserFontError> {
+        if self.read_user().fonts.len() >= MAX_USER_FONTS {
+            return Err(UserFontError::TooMany);
+        }
+        if FileRef::new(&sfnt).is_err() {
+            return Err(UserFontError::Unusable("not a valid OpenType file".into()));
+        }
+        let found = enumerate_faces(&sfnt);
+        if found.is_empty() {
+            return Err(UserFontError::Unusable("no face with a family name".into()));
+        }
+        if found.len() > MAX_FACES_PER_FILE {
+            return Err(UserFontError::Unusable(format!("more than {MAX_FACES_PER_FILE} faces")));
+        }
+        let file = stored_name(name, &sfnt);
+        let data = Arc::new(sfnt);
+        let mut new = Vec::new();
+        for f in found {
+            let label = format!("{} {}", f.family, f.style);
+            let face = make_face(FontBytes::Owned(data.clone()), f.index, f.family, f.style, f.legacy, f.coords)
+                .ok_or_else(|| UserFontError::Unusable(format!("{label} doesn't parse")))?;
+            if face.skrifa().is_none_or(|s| s.charmap().mappings().next().is_none()) {
+                return Err(UserFontError::Unusable(format!("{label} maps no characters")));
+            }
+            new.push(Arc::new(face));
+        }
+        let families = |faces: &[Arc<super::FontFace>]| {
+            let mut v: Vec<String> = faces.iter().map(|f| f.family.clone()).collect();
+            v.dedup();
+            v
+        };
+        let mut user = self.write_user();
+        // Unique among the user fonts (the folder is checked when writing).
+        let file = unique_name(&file, |n| user.fonts.iter().any(|f| f.file.eq_ignore_ascii_case(n)));
+        let added: Vec<Arc<super::FontFace>> = {
+            let mut faces = self.faces.write().unwrap_or_else(|e| e.into_inner());
+            let fresh: Vec<_> = new
+                .iter()
+                .filter(|f| !faces.iter().any(|g| g.family.eq_ignore_ascii_case(&f.family) && g.style.eq_ignore_ascii_case(&f.style)))
+                .cloned()
+                .collect();
+            faces.extend(fresh.iter().cloned());
+            fresh
+        };
+        if added.is_empty() {
+            return Err(UserFontError::AlreadyAvailable(families(&new)));
+        }
+        let font = UserFont {
+            file,
+            faces: added.iter().map(|f| (f.family.clone(), f.style.clone())).collect(),
+            path,
+            face_ids: added.iter().map(|f| f.id).collect(),
+        };
+        user.fonts.push(font.clone());
+        drop(user);
+        self.fonts_changed();
+        Ok(font)
+    }
+
+    /// Forget cached fallback choices and tell watchers ([`FontDb::generation`]).
+    fn fonts_changed(&self) {
+        self.fallbacks.write().unwrap_or_else(|e| e.into_inner()).map.clear();
+        self.generation.fetch_add(1, Ordering::AcqRel);
+    }
+
+    /// Remove the user fonts that added `family` (a typographic or legacy family name): their
+    /// faces leave the font list and their stored files are deleted. Text set in the family falls
+    /// back as for any font that isn't installed. Bundled and system fonts can't be removed.
+    pub fn remove_user_font(&self, family: &str) -> Result<Vec<UserFont>, UserFontError> {
+        let mut user = self.write_user();
+        let ids: Vec<u32> = {
+            let faces = self.read_faces();
+            faces.iter().filter(|f| f.named(family)).map(|f| f.id).collect()
+        };
+        let (gone, kept): (Vec<UserFont>, Vec<UserFont>) = std::mem::take(&mut user.fonts)
+            .into_iter()
+            .partition(|u| u.faces.iter().any(|(f, _)| f.eq_ignore_ascii_case(family)) || u.face_ids.iter().any(|i| ids.contains(i)));
+        user.fonts = kept;
+        drop(user);
+        if gone.is_empty() {
+            return Err(UserFontError::NotUserFont(family.to_string()));
+        }
+        let drop_ids: Vec<u32> = gone.iter().flat_map(|u| u.face_ids.iter().copied()).collect();
+        self.faces.write().unwrap_or_else(|e| e.into_inner()).retain(|f| !drop_ids.contains(&f.id));
+        for u in &gone {
+            if let Some(p) = &u.path
+                && let Err(e) = std::fs::remove_file(p)
+                && e.kind() != std::io::ErrorKind::NotFound
+            {
+                log::warn!("couldn't delete the font file {}: {e}", p.display());
+            }
+        }
+        self.fonts_changed();
+        Ok(gone)
+    }
+
+    /// Use `dir` as the user font folder: load the fonts stored there (each checked like an added
+    /// font; one that fails is logged and skipped) and store fonts added later there. The folder is
+    /// made when the first font is stored. Returns the fonts loaded and the files skipped (with
+    /// why).
+    pub fn load_user_fonts(&self, dir: &Path) -> (Vec<UserFont>, Vec<(String, String)>) {
+        self.write_user().dir = Some(dir.to_path_buf());
+        let mut loaded = Vec::new();
+        let mut skipped = Vec::new();
+        let Ok(rd) = std::fs::read_dir(dir) else { return (loaded, skipped) };
+        let mut paths: Vec<PathBuf> = rd
+            .flatten()
+            .map(|e| e.path())
+            .filter(|p| p.is_file())
+            .filter(|p| p.extension().and_then(|e| e.to_str()).is_some_and(|e| STORED_EXTS.contains(&e.to_ascii_lowercase().as_str())))
+            .collect();
+        paths.sort();
+        for p in paths {
+            let file = p.file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_default();
+            let read = match std::fs::metadata(&p) {
+                Ok(m) if m.len() > MAX_FONT_FILE_BYTES as u64 => {
+                    Err(UserFontError::TooLarge { bytes: usize::try_from(m.len()).unwrap_or(usize::MAX) })
+                }
+                Ok(_) => std::fs::read(&p).map_err(|e| UserFontError::Unusable(e.to_string())),
+                Err(e) => Err(UserFontError::Unusable(e.to_string())),
+            };
+            let r = read.and_then(|b| decode_font_file(&b)).and_then(|sfnt| self.add_user_faces(&file, sfnt, Some(p.clone())));
+            match r {
+                Ok(mut f) => {
+                    // Its own file name, so removing it deletes this file.
+                    if let Some(u) = self.write_user().fonts.iter_mut().find(|u| u.face_ids == f.face_ids) {
+                        u.file.clone_from(&file);
+                    }
+                    f.file = file;
+                    loaded.push(f);
+                }
+                Err(e) => {
+                    log::warn!("skipped the user font {}: {e}", p.display());
+                    skipped.push((file, e.to_string()));
+                }
+            }
+        }
+        (loaded, skipped)
+    }
+}
+
+/// `name`, or `name` with `-2`, `-3`… before its extension, the first that `taken` refuses.
+fn unique_name(name: &str, taken: impl Fn(&str) -> bool) -> String {
+    if !taken(name) {
+        return name.to_string();
+    }
+    let (stem, ext) = name.rsplit_once('.').unwrap_or((name, ""));
+    (2..10_000).map(|n| format!("{stem}-{n}.{ext}")).find(|n| !taken(n)).unwrap_or_else(|| format!("{stem}-x.{ext}"))
+}
+
+/// Write `bytes` to a new file in `dir` named `name` (or a numbered variant when that exists),
+/// through a temporary file so a crash never leaves half a font.
+fn write_unique(dir: &Path, name: &str, bytes: &[u8]) -> std::io::Result<PathBuf> {
+    std::fs::create_dir_all(dir)?;
+    let name = unique_name(name, |n| dir.join(n).exists());
+    let path = dir.join(&name);
+    let tmp = dir.join(format!(".{name}.part"));
+    std::fs::write(&tmp, bytes)?;
+    if let Err(e) = std::fs::rename(&tmp, &path) {
+        let _ = std::fs::remove_file(&tmp);
+        return Err(e);
+    }
+    Ok(path)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    const FAMILY: &str = "Userfont Sans";
+
+    /// A bundled Source Sans 3 file renamed `family` (as long as the original name).
+    pub(crate) fn renamed(file: &str, family: &str) -> Vec<u8> {
+        assert_eq!(family.len(), "Source Sans 3".len());
+        let mut data = std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/fonts").join(file)).unwrap();
+        let utf16 = |s: &str| s.encode_utf16().flat_map(u16::to_be_bytes).collect::<Vec<u8>>();
+        for (from, to) in [(utf16("Source Sans 3"), utf16(family)), (b"Source Sans 3".to_vec(), family.as_bytes().to_vec())] {
+            let mut i = 0;
+            while let Some(at) = data[i..].windows(from.len()).position(|w| w == from) {
+                data[i + at..i + at + to.len()].copy_from_slice(&to);
+                i += at + to.len();
+            }
+        }
+        data
+    }
+
+    fn db() -> FontDb {
+        FontDb::with_font_dirs(vec![])
+    }
+
+    fn temp_dir(name: &str) -> PathBuf {
+        let dir = std::env::temp_dir().join(format!("wc-userfonts-{}-{name}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        dir
+    }
+
+    /// The tables of a TrueType/OpenType font: (tag, data), in directory order.
+    fn tables(font: &[u8]) -> Vec<([u8; 4], Vec<u8>)> {
+        let n = u16::from_be_bytes([font[4], font[5]]) as usize;
+        (0..n)
+            .map(|i| {
+                let r = &font[12 + i * 16..28 + i * 16];
+                let off = u32::from_be_bytes(r[8..12].try_into().unwrap()) as usize;
+                let len = u32::from_be_bytes(r[12..16].try_into().unwrap()) as usize;
+                (r[..4].try_into().unwrap(), font[off..off + len].to_vec())
+            })
+            .collect()
+    }
+
+    /// `font` as a WOFF 1.0 file with every table stored uncompressed (the format allows it).
+    fn woff1(font: &[u8]) -> Vec<u8> {
+        let mut t = tables(font);
+        t.sort_by_key(|x| x.0);
+        let mut out = Vec::new();
+        let dir_end = 44 + 20 * t.len();
+        let mut body = Vec::new();
+        let mut dir = Vec::new();
+        let mut sfnt_size = 12 + 16 * t.len();
+        for (tag, data) in &t {
+            let off = dir_end + body.len();
+            dir.extend_from_slice(tag);
+            dir.extend_from_slice(&(off as u32).to_be_bytes());
+            dir.extend_from_slice(&(data.len() as u32).to_be_bytes());
+            dir.extend_from_slice(&(data.len() as u32).to_be_bytes());
+            dir.extend_from_slice(&0u32.to_be_bytes());
+            body.extend_from_slice(data);
+            body.resize(body.len().next_multiple_of(4), 0);
+            sfnt_size += data.len().next_multiple_of(4);
+        }
+        out.extend_from_slice(b"wOFF");
+        out.extend_from_slice(&font[..4]);
+        out.extend_from_slice(&((dir_end + body.len()) as u32).to_be_bytes());
+        out.extend_from_slice(&(t.len() as u16).to_be_bytes());
+        out.extend_from_slice(&0u16.to_be_bytes());
+        out.extend_from_slice(&(sfnt_size as u32).to_be_bytes());
+        out.extend_from_slice(&[0, 1, 0, 0]); // version 1.0
+        out.extend_from_slice(&[0; 20]); // no metadata, no private data
+        out.extend(dir);
+        out.extend(body);
+        out
+    }
+
+    /// `data` as a brotli stream of uncompressed meta-blocks (RFC 7932 §9.2).
+    fn brotli_stored(data: &[u8]) -> Vec<u8> {
+        struct Bits {
+            out: Vec<u8>,
+            acc: u64,
+            n: u32,
+        }
+        impl Bits {
+            fn put(&mut self, v: u64, bits: u32) {
+                self.acc |= v << self.n;
+                self.n += bits;
+                while self.n >= 8 {
+                    self.out.push(self.acc as u8);
+                    self.acc >>= 8;
+                    self.n -= 8;
+                }
+            }
+            fn align(&mut self) {
+                if self.n > 0 {
+                    self.put(0, 8 - self.n);
+                }
+            }
+        }
+        let mut b = Bits { out: Vec::new(), acc: 0, n: 0 };
+        b.put(0, 1); // WBITS = 16
+        for chunk in data.chunks(1 << 16) {
+            b.put(0, 1); // ISLAST = 0
+            b.put(0, 2); // MNIBBLES = 4
+            b.put(chunk.len() as u64 - 1, 16);
+            b.put(1, 1); // ISUNCOMPRESSED
+            b.align();
+            b.out.extend_from_slice(chunk);
+        }
+        b.put(1, 1); // ISLAST
+        b.put(1, 1); // ISLASTEMPTY
+        b.align();
+        b.out
+    }
+
+    /// WOFF2's UIntBase128.
+    fn base128(mut v: u32, out: &mut Vec<u8>) {
+        let mut bytes = vec![(v & 0x7f) as u8];
+        v >>= 7;
+        while v > 0 {
+            bytes.push((v & 0x7f) as u8 | 0x80);
+            v >>= 7;
+        }
+        out.extend(bytes.into_iter().rev());
+    }
+
+    /// `font` (TrueType) as a WOFF2 file with no table transformed (glyf/loca use the null
+    /// transform, version 3) and the table data in stored brotli blocks.
+    fn woff2(font: &[u8]) -> Vec<u8> {
+        let t = tables(font);
+        let mut dir = Vec::new();
+        let mut stream = Vec::new();
+        for (tag, data) in &t {
+            let null = if tag == b"glyf" || tag == b"loca" { 3 << 6 } else { 0 };
+            dir.push(63 | null);
+            dir.extend_from_slice(tag);
+            base128(data.len() as u32, &mut dir);
+            stream.extend_from_slice(data);
+        }
+        let compressed = brotli_stored(&stream);
+        let mut out = Vec::new();
+        out.extend_from_slice(b"wOF2");
+        out.extend_from_slice(&font[..4]);
+        let total = (48 + dir.len() + compressed.len()).next_multiple_of(4);
+        out.extend_from_slice(&(total as u32).to_be_bytes());
+        out.extend_from_slice(&(t.len() as u16).to_be_bytes());
+        out.extend_from_slice(&0u16.to_be_bytes());
+        let sfnt: usize = 12 + 16 * t.len() + t.iter().map(|(_, d)| d.len().next_multiple_of(4)).sum::<usize>();
+        out.extend_from_slice(&(sfnt as u32).to_be_bytes());
+        out.extend_from_slice(&(compressed.len() as u32).to_be_bytes());
+        out.extend_from_slice(&[0, 1, 0, 0]);
+        out.extend_from_slice(&[0; 20]);
+        out.extend(dir);
+        out.extend(compressed);
+        out.resize(total, 0);
+        out
+    }
+
+    #[test]
+    fn an_added_font_is_listed_resolved_and_measured() {
+        let db = db();
+        let gen0 = db.generation();
+        assert!(!db.has_family(FAMILY));
+        let r = db.install_font("Userfont-Regular.ttf", &renamed("SourceSans3-Regular.ttf", FAMILY)).unwrap();
+        assert_eq!(r.font.families(), vec![FAMILY.to_string()]);
+        assert_eq!(r.font.file, "Userfont-Regular.ttf");
+        assert!(r.font.path.is_none() && r.warning.is_none(), "no folder: kept for the session only");
+        assert!(db.generation() > gen0);
+        assert!(db.families().iter().any(|f| f == FAMILY));
+        let face = db.face(FAMILY, "Regular");
+        assert_eq!(face.family, FAMILY);
+        // Measured with its own glyphs: the copy has Source Sans 3's metrics.
+        let src = db.face("Source Sans 3", "Regular");
+        let g = face.glyph_for('W');
+        assert!(g != 0);
+        assert_eq!(face.advance(g), src.advance(src.glyph_for('W')));
+        assert_eq!(db.user_fonts().len(), 1);
+    }
+
+    #[test]
+    fn the_bundled_baseline_is_never_replaced() {
+        let db = db();
+        let before = db.face("Source Sans 3", "Regular").id();
+        let bytes = std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/fonts/SourceSans3-Regular.ttf")).unwrap();
+        assert!(matches!(db.install_font("x.ttf", &bytes), Err(UserFontError::AlreadyAvailable(_))));
+        assert_eq!(db.face("Source Sans 3", "Regular").id(), before);
+        assert!(db.user_fonts().is_empty());
+        assert!(matches!(db.remove_user_font("Source Sans 3"), Err(UserFontError::NotUserFont(_))));
+        assert!(db.has_family("Source Sans 3"));
+    }
+
+    #[test]
+    fn junk_is_rejected_without_adding_anything() {
+        let db = db();
+        let n = db.families().len();
+        let regular = renamed("SourceSans3-Regular.ttf", FAMILY);
+        let mut cases: Vec<Vec<u8>> = vec![
+            vec![],
+            b"not a font at all".to_vec(),
+            b"\0\x01\0\0".to_vec(),
+            b"\0\x01\0\0\xff\xff\0\0\0\0\0\0".to_vec(),
+            b"ttcf\0\x01\0\0\xff\xff\xff\xff".to_vec(),
+            b"OTTO\0\x01".to_vec(),
+            b"wOFF\0\x01\0\0\0\0\0\x08".to_vec(),
+            b"wOF2\0\x01\0\0\xff\xff\xff\xff\0\x05".to_vec(),
+            regular[..regular.len() / 3].to_vec(),
+        ];
+        // Damaged web fonts: every prefix, and flipped bytes through the headers and directory.
+        for packed in [woff1(&regular), woff2(&regular)] {
+            for cut in [8, 20, 44, 47, 48, 60, 100, 300, packed.len() / 2, packed.len() - 1] {
+                cases.push(packed[..cut.min(packed.len())].to_vec());
+            }
+            for at in 4..200 {
+                let mut b = packed.clone();
+                b[at] ^= 0xA5;
+                cases.push(b);
+            }
+        }
+        for (i, c) in cases.iter().enumerate() {
+            let r = db.install_font("junk.ttf", c);
+            // A flipped byte inside a table can leave a usable font; the cut-off files can't.
+            assert!(i >= 9 || r.is_err(), "case {i}");
+        }
+        assert_eq!(db.families().len(), n + db.user_fonts().iter().map(|u| u.families().len()).sum::<usize>());
+        let mut big = regular.clone();
+        big.resize(MAX_FONT_FILE_BYTES + 1, 0);
+        assert!(matches!(db.install_font("big.ttf", &big), Err(UserFontError::TooLarge { .. })));
+    }
+
+    #[test]
+    fn woff_and_woff2_are_unwrapped() {
+        let regular = renamed("SourceSans3-Regular.ttf", FAMILY);
+        for (name, packed) in [("a.woff", woff1(&regular)), ("a.woff2", woff2(&regular))] {
+            assert!(is_font_file_name(name));
+            let db = db();
+            let r = db.install_font(name, &packed).unwrap_or_else(|e| panic!("{name}: {e}"));
+            assert_eq!(r.font.file, "a.ttf", "stored unwrapped");
+            let face = db.face(FAMILY, "Regular");
+            assert_eq!(face.family, FAMILY);
+            assert!(face.glyph_for('g') != 0);
+        }
+    }
+
+    #[test]
+    fn user_fonts_are_stored_loaded_and_removed() {
+        let dir = temp_dir("store");
+        let db = db();
+        let (loaded, skipped) = db.load_user_fonts(&dir);
+        assert!(loaded.is_empty() && skipped.is_empty(), "a missing folder is empty");
+        let r = db.install_font("../../evil/Userfont Bold?.woff2", &woff2(&renamed("SourceSans3-Bold.ttf", FAMILY))).unwrap();
+        assert!(r.warning.is_none());
+        let path = r.font.path.clone().unwrap();
+        assert_eq!(path.parent(), Some(dir.as_path()), "a file name can't leave the folder");
+        assert_eq!(r.font.file, "Userfont Bold_.ttf");
+        assert!(path.exists());
+        db.install_font("Userfont-Regular.ttf", &renamed("SourceSans3-Regular.ttf", FAMILY)).unwrap();
+        // A damaged file in the folder is skipped, never fatal.
+        std::fs::write(dir.join("damaged.ttf"), b"ttcf\0\x01\0\0\xff\xff\xff\xff").unwrap();
+        std::fs::write(dir.join("notes.txt"), b"hello").unwrap();
+
+        // The next start loads both from the folder.
+        let next = super::super::FontDb::with_font_dirs(vec![]);
+        let (loaded, skipped) = next.load_user_fonts(&dir);
+        assert_eq!(loaded.len(), 2, "{skipped:?}");
+        assert_eq!(skipped.len(), 1);
+        assert_eq!(next.styles(FAMILY), vec!["Regular".to_string(), "Bold".to_string()]);
+        assert_eq!(next.face(FAMILY, "Bold").style, "Bold");
+
+        // Removing the family deletes both files; text in it falls back.
+        let gone = next.remove_user_font(FAMILY).unwrap();
+        assert_eq!(gone.len(), 2);
+        assert!(!next.has_family(FAMILY));
+        assert_eq!(next.face(FAMILY, "Regular").family, super::super::FALLBACK_FAMILY);
+        assert!(!path.exists());
+        assert!(next.user_fonts().is_empty());
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    #[test]
+    fn stored_names_are_safe_and_unique() {
+        let ttf = renamed("SourceSans3-Regular.ttf", FAMILY);
+        assert_eq!(stored_name("C:\\x\\..\\a.b.TTF", &ttf), "a_b.ttf");
+        assert_eq!(stored_name("", &ttf), "font.ttf");
+        assert_eq!(stored_name("-rf.otf", b"OTTO"), "font-rf.otf");
+        assert_eq!(unique_name("a.ttf", |n| n == "a.ttf" || n == "a-2.ttf"), "a-3.ttf");
+    }
+}
diff --git a/crates/fonts/src/lib.rs b/crates/fonts/src/lib.rs
index 2ac6ecae11..15c9c2c8f0 100644
--- a/crates/fonts/src/lib.rs
+++ b/crates/fonts/src/lib.rs
@@ -9,16 +9,21 @@
 
 mod fontdb;
 pub mod math;
+mod script;
 mod ui_fallback;
 pub mod word;
 
-pub use fontdb::{FALLBACK_FAMILY, FaceRef, FontDb, FontFace, base_style, bundled, system_font_dirs};
+pub use fontdb::{
+    FALLBACK_FAMILY, FONT_FILE_EXTS, FaceRef, FontDb, FontFace, FontFormat, Installed, LocalName, MAX_FONT_FILE_BYTES, UserFont, UserFontError,
+    base_style, bundled, decode_font_file, is_font_file_name, name_language_matches, sniff, system_font_dirs,
+};
 pub use harfrust::Feature;
 use harfrust::{Direction, ShapeOptions, Tag, UnicodeBuffer};
 pub use kurbo::BezPath;
+pub use script::{fallback_rank, needs_layout_tables, script_fallbacks};
 use skrifa::MetadataProvider;
 use skrifa::instance::Size;
-pub use ui_fallback::{SystemUiFont, system_cjk_ui_font, ui_needs_system_cjk};
+pub use ui_fallback::{SystemUiFont, is_cjk, system_cjk_ui_font, ui_needs_system_cjk, ui_uncovered_cjk};
 
 /// A font from the optional craft-fonts build input (https://github.com/storytold/craft-fonts;
 /// empty unless built with `CRAFT_FONTS_DIR`, see `build.rs`).
@@ -180,21 +185,27 @@ fn shape_dir(face: &FontFace, text: &str, features: &[Feature], map: &impl Fn(ch
     let mut out = Vec::with_capacity(text.len());
     let shaped = face.hb().map(|hb| {
         let shaper = face.shaper.shaper(&hb).instance(face.instance.as_ref()).build();
-        let mut buf = UnicodeBuffer::new();
-        for (i, c) in text.char_indices() {
-            buf.add(map(c), i as u32);
-        }
-        buf.guess_segment_properties();
-        buf.set_direction(if rtl { Direction::RightToLeft } else { Direction::LeftToRight });
-        let gb = shaper.shape(buf, ShapeOptions::new().features(features));
-        for (info, pos) in gb.glyph_infos().iter().zip(gb.glyph_positions()) {
-            out.push(ShapedGlyph {
-                gid: info.glyph_id,
-                cluster: info.cluster as usize,
-                x_advance: pos.x_advance,
-                x_offset: pos.x_offset,
-                y_offset: pos.y_offset,
-            });
+        // One script per shaping call: the shaper picks its script engine (Myanmar, Khmer,
+        // Indic, USE reordering…) from the run's script, so "Hi မြန်မာ" in one face must not be
+        // shaped as Latin. Runs come in text order; right-to-left callers regroup by cluster.
+        for r in script::script_runs(text) {
+            let Some(sub) = text.get(r.clone()) else { continue };
+            let mut buf = UnicodeBuffer::new();
+            for (i, c) in sub.char_indices() {
+                buf.add(map(c), (r.start + i) as u32);
+            }
+            buf.guess_segment_properties();
+            buf.set_direction(if rtl { Direction::RightToLeft } else { Direction::LeftToRight });
+            let gb = shaper.shape(buf, ShapeOptions::new().features(features));
+            for (info, pos) in gb.glyph_infos().iter().zip(gb.glyph_positions()) {
+                out.push(ShapedGlyph {
+                    gid: info.glyph_id,
+                    cluster: info.cluster as usize,
+                    x_advance: pos.x_advance,
+                    x_offset: pos.x_offset,
+                    y_offset: pos.y_offset,
+                });
+            }
         }
     });
     if shaped.is_none()
diff --git a/crates/fonts/src/script.rs b/crates/fonts/src/script.rs
new file mode 100644
index 0000000000..1c7c9609af
--- /dev/null
+++ b/crates/fonts/src/script.rs
@@ -0,0 +1,135 @@
+//! Scripts: itemising text into single-script runs for the shaper, and the fonts preferred when
+//! a document's font lacks a complex script (Myanmar, Khmer, the Indic scripts, Thai…).
+//!
+//! A shaper picks its script-specific engine (the Myanmar, Khmer, Indic or Universal Shaping
+//! Engine reordering, e.g. U+1031 ေ drawn before its consonant) from the run's script, so text
+//! mixing scripts in one face must be shaped one script at a time.
+
+#![allow(clippy::single_range_in_vec_init)] // one run is a list of runs
+
+use unicode_script::{Script, UnicodeScript};
+
+/// The script of `c` for itemisation: `None` for characters that take the script of the text
+/// around them (spaces, punctuation, digits, combining marks, joiners).
+fn real_script(c: char) -> Option<Script> {
+    match c.script() {
+        Script::Common | Script::Inherited | Script::Unknown => None,
+        // Japanese and Chinese mix these within a word: one run.
+        Script::Hiragana | Script::Katakana | Script::Bopomofo => Some(Script::Han),
+        s => Some(s),
+    }
+}
+
+/// Maximal single-script byte ranges of `text`. Characters of no particular script join the run
+/// before them (or, at the start, the first run), so the ranges cover `text` exactly.
+pub(crate) fn script_runs(text: &str) -> Vec<std::ops::Range<usize>> {
+    if text.is_ascii() {
+        return vec![0..text.len()];
+    }
+    let mut runs = Vec::new();
+    let mut cur: Option<Script> = None;
+    let mut start = 0;
+    for (i, c) in text.char_indices() {
+        let Some(s) = real_script(c) else { continue };
+        match cur {
+            Some(p) if p != s => {
+                runs.push(start..i);
+                start = i;
+                cur = Some(s);
+            }
+            None => cur = Some(s),
+            _ => {}
+        }
+    }
+    runs.push(start..text.len());
+    runs
+}
+
+/// Scripts whose shaping reorders, stacks or forms clusters (OpenType script-specific engines),
+/// so a fallback font must carry OpenType layout tables to draw them properly.
+pub fn needs_layout_tables(c: char) -> bool {
+    matches!(
+        c.script(),
+        Script::Myanmar
+            | Script::Khmer
+            | Script::Devanagari
+            | Script::Bengali
+            | Script::Gurmukhi
+            | Script::Gujarati
+            | Script::Oriya
+            | Script::Tamil
+            | Script::Telugu
+            | Script::Kannada
+            | Script::Malayalam
+            | Script::Sinhala
+            | Script::Thai
+            | Script::Lao
+            | Script::Tibetan
+            | Script::Tai_Tham
+            | Script::Balinese
+            | Script::Javanese
+            | Script::Arabic
+            | Script::Syriac
+    )
+}
+
+/// Families preferred, in order, for a character of `c`'s script when the document's font lacks
+/// it: the platforms' own OpenType fonts and the open Noto/SIL families. Apple's older fonts for
+/// these scripts carry only AAT tables (which the shaper doesn't read), so they come last.
+pub fn script_fallbacks(c: char) -> &'static [&'static str] {
+    match c.script() {
+        Script::Myanmar => &["Myanmar Text", "Noto Sans Myanmar", "Padauk", "Pyidaungsu", "Noto Serif Myanmar", "Myanmar Sangam MN", "Myanmar MN"],
+        Script::Khmer => &["Leelawadee UI", "Khmer UI", "Noto Sans Khmer", "Noto Serif Khmer", "Khmer OS", "Khmer Sangam MN", "Khmer MN"],
+        Script::Devanagari => &["Nirmala UI", "Mangal", "Kohinoor Devanagari", "Noto Sans Devanagari", "Noto Serif Devanagari", "Lohit Devanagari"],
+        Script::Bengali => &["Nirmala UI", "Vrinda", "Kohinoor Bangla", "Noto Sans Bengali", "Noto Serif Bengali", "Lohit Bengali"],
+        Script::Thai => &["Leelawadee UI", "Leelawadee", "Tahoma", "Thonburi", "Noto Sans Thai", "Noto Serif Thai"],
+        Script::Lao => &["Leelawadee UI", "Lao UI", "Noto Sans Lao", "Noto Serif Lao", "Lao Sangam MN"],
+        Script::Tamil | Script::Telugu | Script::Kannada | Script::Malayalam | Script::Gujarati | Script::Gurmukhi | Script::Oriya => &["Nirmala UI"],
+        _ => &[],
+    }
+}
+
+/// How well `family` suits `c` as a fallback: 0 for the first preferred family, then the others
+/// in order; then families named after the script ("Noto Sans Tamil"); then everything else.
+pub fn fallback_rank(c: char, family: &str) -> usize {
+    let list = script_fallbacks(c);
+    if let Some(i) = list.iter().position(|n| family.eq_ignore_ascii_case(n)) {
+        return i;
+    }
+    if needs_layout_tables(c) {
+        let name = c.script().full_name().replace('_', " ");
+        if family.to_ascii_lowercase().contains(&name.to_ascii_lowercase()) {
+            return list.len();
+        }
+    }
+    list.len() + 1
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn runs_split_by_script_and_neutrals_join_their_neighbours() {
+        assert_eq!(script_runs("Hello"), vec![0..5]);
+        // "Hi မြန်မာ!" → Latin "Hi ", Myanmar "မြန်မာ!".
+        let s = "Hi မြန်မာ!";
+        let runs = script_runs(s);
+        assert_eq!(runs, vec![0..3, 3..s.len()]);
+        // A leading neutral joins the first run; marks never start a run.
+        assert_eq!(script_runs("(ကေ)"), vec![0.."(ကေ)".len()]);
+        // Japanese kana and kanji stay together.
+        assert_eq!(script_runs("日本語のテキスト").len(), 1);
+        assert_eq!(script_runs(""), vec![0..0]);
+    }
+
+    #[test]
+    fn complex_scripts_prefer_their_own_fonts() {
+        assert!(needs_layout_tables('မ') && needs_layout_tables('ក') && needs_layout_tables('क'));
+        assert!(!needs_layout_tables('a') && !needs_layout_tables('語'));
+        assert_eq!(fallback_rank('မ', "Myanmar Text"), 0);
+        assert!(fallback_rank('မ', "Noto Sans Myanmar") < fallback_rank('မ', "Myanmar Sangam MN"));
+        assert!(fallback_rank('த', "Noto Sans Tamil") < fallback_rank('த', "Arial"));
+        assert_eq!(fallback_rank('a', "Arial"), fallback_rank('a', "Noto Sans"));
+    }
+}
diff --git a/crates/fonts/src/tests_sysfonts.rs b/crates/fonts/src/tests_sysfonts.rs
index ee6148b046..d51fd64310 100644
--- a/crates/fonts/src/tests_sysfonts.rs
+++ b/crates/fonts/src/tests_sysfonts.rs
@@ -58,6 +58,11 @@ fn font_dir(name: &str) -> PathBuf {
     dir
 }
 
+/// (family, style, legacy family) of each face the scan finds in the file at `path`.
+fn names(path: &Path) -> Vec<(String, String, String)> {
+    file_face_names(path).into_iter().map(|f| (f.family, f.style, f.legacy)).collect()
+}
+
 fn has(list: &[String], family: &str) -> bool {
     list.iter().any(|f| f == family)
 }
@@ -171,7 +176,7 @@ fn fallback_lookups_are_remembered_until_fonts_load() {
 #[test]
 fn the_scan_reads_names_without_loading_the_font() {
     let dir = font_dir("names");
-    assert_eq!(file_face_names(&dir.join("Sysfont-Regular.ttf")), [(FAMILY.to_string(), "Regular".to_string(), FAMILY.to_string())]);
+    assert_eq!(names(&dir.join("Sysfont-Regular.ttf")), [(FAMILY.to_string(), "Regular".to_string(), FAMILY.to_string())]);
     assert!(file_face_names(&dir.join("damaged.ttf")).is_empty());
     assert!(file_face_names(&dir.join("readme.txt")).is_empty());
     assert!(file_face_names(&dir.join("missing.ttf")).is_empty());
@@ -184,7 +189,7 @@ fn installed_weights_are_found_by_their_legacy_family_name() {
     let dir = font_dir("legacy");
     std::fs::write(dir.join("Sysfont-Semibold.ttf"), renamed("SourceSans3-Semibold.ttf")).unwrap();
     let semibold = format!("{FAMILY} Semibold");
-    assert_eq!(file_face_names(&dir.join("Sysfont-Semibold.ttf")), [(FAMILY.to_string(), "Semibold".to_string(), semibold.clone())]);
+    assert_eq!(names(&dir.join("Sysfont-Semibold.ttf")), [(FAMILY.to_string(), "Semibold".to_string(), semibold.clone())]);
     let db = || FontDb::with_font_dirs(vec![dir.clone()]);
     assert!(has(&db().families(), FAMILY) && has(&db().families(), &semibold));
     assert!(db().has_family(&semibold.to_uppercase()));
@@ -216,7 +221,7 @@ fn the_scan_lists_a_variable_fonts_named_instances_as_loading_it_does() {
     };
     let data = std::fs::read(path).unwrap();
     let loaded: Vec<(String, String, String)> = enumerate_faces(&data).into_iter().map(|f| (f.family, f.style, f.legacy)).collect();
-    assert_eq!(file_face_names(path), loaded);
+    assert_eq!(names(path), loaded);
     if loaded.len() > 1 {
         // Instances other than Regular, Bold and Italic have names of their own.
         assert!(loaded.iter().any(|(family, _, legacy)| family != legacy), "{loaded:?}");
@@ -244,3 +249,157 @@ fn fallback_cache_is_dropped_when_a_face_loads_by_its_legacy_family_name() {
     assert_eq!(cache.faces, db.read_faces().len());
     assert!(!cache.map.contains_key(&(thai, latin.id())), "answers from before the load are dropped");
 }
+
+#[test]
+fn fallback_reads_each_installed_font_file_once_however_many_characters_miss() {
+    // #605: every distinct character no font covers read every installed font file again.
+    let dir = font_dir("coverage");
+    // The installed Regular also maps U+30000 (no bundled font does): its last cmap group, the
+    // single character U+1F916, moved there (still the highest, so the groups stay sorted).
+    let mut regular = renamed("SourceSans3-Regular.ttf");
+    let (from, to) = ([0x0001_F916_u32.to_be_bytes(); 2].concat(), [0x0003_0000_u32.to_be_bytes(); 2].concat());
+    let mut patched = 0;
+    while let Some(at) = regular.windows(from.len()).position(|w| w == from) {
+        regular[at..at + to.len()].copy_from_slice(&to);
+        patched += 1;
+    }
+    assert!(patched > 0);
+    std::fs::write(dir.join("Sysfont-Regular.ttf"), regular).unwrap();
+    let db = FontDb::with_font_dirs(vec![dir]);
+    let latin = db.face(FALLBACK_FAMILY, "Regular");
+    let found = db.fallback_for('\u{30000}', latin.id()).expect("the installed font maps it");
+    assert_eq!((found.family.as_str(), found.style.as_str()), (FAMILY, "Regular"));
+    // 2,000 distinct characters nothing maps: the index answers, no file is read again.
+    for cp in 0x30001..0x30001 + 2000 {
+        let c = char::from_u32(cp).unwrap();
+        assert!(db.fallback_for(c, latin.id()).is_none());
+    }
+    let index = db.coverage.lock().unwrap();
+    assert_eq!(index.files.len(), 2, "Regular and Bold are cataloged");
+    assert_eq!(index.reads, 2, "each file read once");
+}
+
+#[test]
+fn coverage_ranges_hold_exactly_the_mapped_characters() {
+    let data = renamed("SourceSans3-Regular.ttf");
+    let ranges = coverage_ranges(&data);
+    assert!(ranges.windows(2).all(|w| w[0].1 + 1 < w[1].0), "sorted, disjoint and merged");
+    let font = skrifa::FontRef::new(&data).unwrap();
+    let mapped: Vec<u32> = font.charmap().mappings().map(|(cp, _)| cp).collect();
+    assert!(ranges.len() < mapped.len() / 4, "ranges, not a set of characters");
+    assert!(mapped.iter().all(|cp| ranges_hold(&ranges, *cp)));
+    for cp in [0x0, 0x9, 0x0E01, 0x17000, 0x10_FFFF] {
+        assert_eq!(ranges_hold(&ranges, cp), font.charmap().map(cp).is_some(), "U+{cp:04X}");
+    }
+    // Damaged data indexes as nothing.
+    assert!(coverage_ranges(b"ttcf\0\x01\0\0\xff\xff\xff\xff").is_empty());
+    assert!(coverage_ranges(&data[..100]).is_empty());
+}
+
+/// A bundled font renamed by a `name` table holding just its family names: (Windows language id,
+/// name) pairs, English (0x0409) first, as SimSun's names 宋体 for Simplified Chinese.
+fn with_family_names(file: &str, names: &[(u16, &str)]) -> Vec<u8> {
+    let data = std::fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/fonts").join(file)).unwrap();
+    let font = skrifa::FontRef::new(&data).unwrap();
+    // Records sorted by language, then name ID: family (1) and subfamily (2, English only).
+    let mut records: Vec<(u16, u16, Vec<u8>)> =
+        names.iter().map(|(lang, n)| (*lang, 1, n.encode_utf16().flat_map(u16::to_be_bytes).collect())).collect();
+    records.push((0x0409, 2, "Regular".encode_utf16().flat_map(u16::to_be_bytes).collect()));
+    records.sort_by_key(|r| (r.0, r.1));
+    let mut name = Vec::new();
+    for v in [0u16, records.len() as u16, (6 + 12 * records.len()) as u16] {
+        name.extend_from_slice(&v.to_be_bytes());
+    }
+    let mut offset = 0u16;
+    for (lang, id, s) in &records {
+        for v in [3u16, 1, *lang, *id, s.len() as u16, offset] {
+            name.extend_from_slice(&v.to_be_bytes());
+        }
+        offset += s.len() as u16;
+    }
+    for (_, _, s) in &records {
+        name.extend_from_slice(s);
+    }
+    let mut tables: Vec<([u8; 4], Vec<u8>)> = font
+        .table_directory()
+        .table_records()
+        .iter()
+        .filter(|r| r.tag() != skrifa::Tag::new(b"name"))
+        .map(|r| (r.tag().to_be_bytes(), font.table_data(r.tag()).unwrap().as_bytes().to_vec()))
+        .collect();
+    tables.push((*b"name", name));
+    tables.sort_by_key(|t| t.0);
+    mini_font(&tables)
+}
+
+#[test]
+fn chinese_fonts_are_listed_by_their_chinese_names_in_a_chinese_interface() {
+    // #505: the font list showed fonts only by their English names (SimSun, never 宋体). Here a
+    // Chinese font is the second face of a collection, as in simsun.ttc and msyh.ttc.
+    let dir = font_dir("localized");
+    let song = with_family_names("SourceSans3-Regular.ttf", &[(0x0409, "Songti Test"), (0x0804, "测试宋体"), (0x0404, "測試宋體")]);
+    std::fs::write(dir.join("song.ttc"), collection(&[renamed("SourceSans3-Semibold.ttf"), song])).unwrap();
+    let db = FontDb::with_font_dirs(vec![dir]);
+    // English names in the English list; the Chinese names in place of them in a Chinese one.
+    assert!(has(&db.families(), "Songti Test") && !has(&db.families(), "测试宋体"));
+    assert!(has(&db.families_in("en"), "Songti Test"));
+    let hans = db.families_in("zh-hans");
+    assert!(has(&hans, "测试宋体") && !has(&hans, "Songti Test") && has(&hans, FAMILY), "{hans:?}");
+    assert!(has(&db.families_in("zh-hant"), "測試宋體"));
+    assert_eq!(db.localized_names("zh-hans"), [("Songti Test".to_string(), "测试宋体".to_string())]);
+    // Either name finds the font, before and after it loads.
+    assert!(db.has_family("测试宋体") && db.has_family("測試宋體"));
+    assert_eq!(db.styles("测试宋体"), ["Regular"]);
+    let f = db.face("测试宋体", "Regular");
+    assert_eq!((f.family.as_str(), f.index()), ("Songti Test", 1));
+    assert_eq!(db.face("測試宋體", "Bold").id(), f.id());
+    assert_eq!(db.english_family("测试宋体").as_deref(), Some("Songti Test"));
+    assert!(db.has_family("测试宋体"));
+    // Name table languages against interface languages.
+    for (ui, tag, ok) in [
+        ("zh-hans", "zh-Hans", true),
+        ("zh-hans", "zh-SG", true),
+        ("zh-hans", "zh-TW", false),
+        ("zh-hant", "zh-HK", true),
+        ("zh-hant", "zh-Hans", false),
+        ("ja", "ja-JP", true),
+        ("ja", "ko-KR", false),
+        ("en", "zh-Hans", false),
+    ] {
+        assert_eq!(name_language_matches(ui, tag), ok, "{ui} {tag}");
+    }
+}
+
+/// `data` with its OS/2 code page bits (`ulCodePageRange1`) set to `pages`.
+fn with_code_pages(data: &[u8], pages: u32) -> Vec<u8> {
+    let font = skrifa::FontRef::new(data).unwrap();
+    let tables: Vec<([u8; 4], Vec<u8>)> = font
+        .table_directory()
+        .table_records()
+        .iter()
+        .map(|r| {
+            let mut t = font.table_data(r.tag()).unwrap().as_bytes().to_vec();
+            if r.tag() == skrifa::Tag::new(b"OS/2") {
+                t[78..82].copy_from_slice(&pages.to_be_bytes());
+            }
+            (r.tag().to_be_bytes(), t)
+        })
+        .collect();
+    mini_font(&tables)
+}
+
+#[test]
+fn east_asian_fonts_are_listed_for_the_asian_text_font_box() {
+    // #505: the Font dialog's Asian text font box lists the Chinese, Japanese and Korean fonts,
+    // found by their OS/2 code pages (here GB2312) during the scan, without loading them.
+    let dir = font_dir("eastasian");
+    let song = with_family_names("SourceSans3-Regular.ttf", &[(0x0409, "Songti Test"), (0x0804, "测试宋体")]);
+    std::fs::write(dir.join("song.ttf"), with_code_pages(&song, 1 << 18)).unwrap();
+    let db = FontDb::with_font_dirs(vec![dir]);
+    let listed = |db: &FontDb| db.east_asian_families().iter().filter(|f| *f == "Songti Test").count();
+    assert_eq!(listed(&db), 1);
+    assert!(!has(&db.east_asian_families(), FAMILY), "Latin fonts are left out");
+    // Loaded, it is still listed once.
+    assert!(db.face("Songti Test", "Regular").is_east_asian());
+    assert_eq!(listed(&db), 1);
+}
diff --git a/crates/fonts/src/ui_fallback.rs b/crates/fonts/src/ui_fallback.rs
index 5427f0289b..6cbe8f7944 100644
--- a/crates/fonts/src/ui_fallback.rs
+++ b/crates/fonts/src/ui_fallback.rs
@@ -1,7 +1,8 @@
-//! An installed CJK font for the interface when no embedded craft-fonts face covers the interface
-//! language (#241): a build without craft-fonts, or one whose craft-fonts checkout lacks the
-//! Chinese face, would otherwise draw Chinese menus as boxes. Native only; wasm has no system
-//! fonts to read.
+//! An installed CJK font for the interface, after the embedded craft-fonts faces, when they leave
+//! characters of the interface text without a glyph: a build without craft-fonts, one whose
+//! craft-fonts checkout lacks the Chinese face (#241), or one whose faces lack characters the
+//! catalogs use (#486) would otherwise draw Chinese menus with boxes and `?`. Native only; wasm
+//! has no system fonts to read.
 //!
 //! It looks for a short list of well-known files in the platform's font folders
 //! ([`system_font_dirs`](crate::system_font_dirs)) rather than waiting for the full system font
@@ -22,31 +23,72 @@ pub struct SystemUiFont {
     pub index: u32,
 }
 
-/// Do the embedded interface faces (`ui_cjk_fonts`) leave the interface without CJK glyphs it
-/// needs? A Chinese interface (`prefer_hans`) needs a Chinese (`Hans`) face: the Japanese one
-/// lacks the simplified-only hanzi (页, 选, 删 …). Any other interface still needs some CJK face,
-/// for the language names in the Options menu and CJK file names.
-pub fn ui_needs_system_cjk(prefer_hans: bool, embedded: &[&CraftFont]) -> bool {
-    if prefer_hans { !embedded.iter().any(|f| f.scripts.contains(&"Hans")) } else { embedded.is_empty() }
+/// Is `c` drawn from a CJK font: Han ideographs, kana, bopomofo, Hangul, CJK punctuation or a
+/// full-width form? (Latin, Cyrillic and symbols come from the interface's Latin faces.)
+pub fn is_cjk(c: char) -> bool {
+    matches!(c,
+        '\u{2E80}'..='\u{2FDF}' // radicals
+        | '\u{3000}'..='\u{33FF}' // punctuation, kana, bopomofo, compatibility
+        | '\u{3400}'..='\u{4DBF}' // extension A
+        | '\u{4E00}'..='\u{9FFF}' // unified ideographs
+        | '\u{AC00}'..='\u{D7AF}' // Hangul syllables
+        | '\u{F900}'..='\u{FAFF}' // compatibility ideographs
+        | '\u{FE30}'..='\u{FE4F}' // vertical forms
+        | '\u{FF00}'..='\u{FFEF}' // full-width forms
+        | '\u{20000}'..='\u{3FFFF}' // extensions B and later
+    )
+}
+
+/// The distinct CJK characters of `texts` (see [`is_cjk`]) that none of the `embedded` faces
+/// maps, in code point order. A craft-fonts face may lack characters the interface catalogs use
+/// (an older or subset file), and those would draw as boxes or `?` (#486).
+pub fn ui_uncovered_cjk(texts: &[&str], embedded: &[&CraftFont]) -> Vec<char> {
+    let faces: Vec<_> = embedded.iter().filter_map(|f| skrifa::FontRef::from_index(f.bytes, 0).ok()).map(|f| f.charmap()).collect();
+    let chars: std::collections::BTreeSet<char> = texts.iter().flat_map(|t| t.chars()).filter(|c| is_cjk(*c)).collect();
+    chars.into_iter().filter(|c| !faces.iter().any(|m| m.map(*c).is_some())).collect()
+}
+
+/// Do the embedded interface faces (`ui_cjk_fonts`) leave CJK characters of `texts` (the
+/// interface catalogs and language names that can be on screen) without a glyph? Then an
+/// installed CJK font goes after them. No embedded face (a build without craft-fonts) leaves
+/// every CJK character uncovered; a Japanese face alone lacks the simplified-only hanzi (页, 选,
+/// 删 …, #241) and some traditional ones (啟, 內 …, #486).
+pub fn ui_needs_system_cjk(texts: &[&str], embedded: &[&CraftFont]) -> bool {
+    !ui_uncovered_cjk(texts, embedded).is_empty()
 }
 
 /// Files larger than this are skipped (the big system CJK collections are around 20–80 MB).
 const MAX_FILE: u64 = 128 << 20;
 /// Faces looked at in one collection.
 const MAX_FACES: u32 = 64;
+/// Entries looked at in one macOS font asset folder (each font is one `<hash>.asset` folder).
+const MAX_ASSETS: usize = 8192;
+/// Characters a face's coverage is measured on.
+const MAX_NEEDED: usize = 4096;
 
 /// A character only a font for the language has: a simplified-only hanzi, or kana.
 fn probe(hans: bool) -> char {
     if hans { '页' } else { 'の' }
 }
 
-/// Font files to look for, relative to a font folder, best first. Chinese faces cover kana too,
-/// so the Japanese list ends with the Chinese one.
+/// Font files to look for, relative to a font folder (or absolute), best first. Chinese faces
+/// cover kana too, so the Japanese list ends with the Chinese one.
 fn candidates(hans: bool) -> Vec<&'static str> {
     let (zh, ja): (&[&str], &[&str]) = if cfg!(windows) {
         (&["Deng.ttf", "msyh.ttc", "simhei.ttf", "simsun.ttc", "NotoSansSC-VF.ttf"], &["YuGothR.ttc", "meiryo.ttc", "msgothic.ttc"])
     } else if cfg!(target_os = "macos") {
-        (&["PingFang.ttc", "Hiragino Sans GB.ttc", "STHeiti Light.ttc", "STHeiti Medium.ttc"], &["ヒラギノ角ゴシック W3.ttc", "Hiragino Sans W3.ttc"])
+        (
+            &[
+                // An asset on macOS 10.15 and later (see `with_asset_data`).
+                "PingFang.ttc",
+                "Hiragino Sans GB.ttc",
+                "STHeiti Light.ttc",
+                "STHeiti Medium.ttc",
+                // The system interface's own copy, present when the PingFang asset isn't.
+                "/System/Library/PrivateFrameworks/FontServices.framework/Resources/Reserved/PingFangUI.ttc",
+            ],
+            &["ヒラギノ角ゴシック W3.ttc", "Hiragino Sans W3.ttc"],
+        )
     } else {
         (
             &[
@@ -69,31 +111,67 @@ fn candidates(hans: bool) -> Vec<&'static str> {
     if hans { zh.to_vec() } else { ja.iter().chain(zh).copied().collect() }
 }
 
-/// The installed CJK font for a Chinese (`hans`) or other interface, if one is found. Reads at
-/// most one font file per candidate; never panics on damaged files.
-pub fn system_cjk_ui_font(hans: bool) -> Option<SystemUiFont> {
-    find_ui_font(&crate::system_font_dirs(), &candidates(hans), probe(hans), hans)
+/// The installed CJK font for a Chinese (`hans`) or other interface that best covers `needed`
+/// (the characters the embedded faces lack; empty: a character typical of the language), if one
+/// is found. Never panics on damaged files.
+pub fn system_cjk_ui_font(hans: bool, needed: &[char]) -> Option<SystemUiFont> {
+    let probe = [probe(hans)];
+    let needed = if needed.is_empty() { &probe[..] } else { needed.get(..MAX_NEEDED).unwrap_or(needed) };
+    find_ui_font(&with_asset_data(crate::system_font_dirs()), &candidates(hans), needed, hans)
 }
 
-/// The first of `names` (tried in order, each in every folder of `dirs`) that is a font file
-/// with a face mapping `probe`.
-pub(crate) fn find_ui_font(dirs: &[std::path::PathBuf], names: &[&str], probe: char, hans: bool) -> Option<SystemUiFont> {
-    names.iter().flat_map(|n| dirs.iter().map(move |d| d.join(n))).find_map(|path| {
-        let size = std::fs::metadata(&path).ok().filter(|m| m.is_file())?.len();
-        if size > MAX_FILE {
-            return None;
+/// `dirs` and, for each macOS font asset folder among them (`com_apple_MobileAsset_Font<N>`),
+/// the `AssetData` folder of every `<hash>.asset` in it: macOS ships PingFang there, e.g.
+/// `/System/Library/AssetsV2/com_apple_MobileAsset_Font7/<hash>.asset/AssetData/PingFang.ttc`
+/// (#486). One level, at most [`MAX_ASSETS`] entries per folder.
+pub(crate) fn with_asset_data(dirs: Vec<std::path::PathBuf>) -> Vec<std::path::PathBuf> {
+    let mut out = Vec::with_capacity(dirs.len());
+    for d in dirs {
+        let assets = d.file_name().is_some_and(|n| n.to_string_lossy().starts_with("com_apple_MobileAsset_Font"));
+        if assets && let Ok(entries) = std::fs::read_dir(&d) {
+            let mut found: Vec<_> =
+                entries.flatten().take(MAX_ASSETS).map(|e| e.path()).filter(|p| p.extension().is_some_and(|x| x == "asset")).collect();
+            found.sort();
+            out.extend(found.into_iter().map(|p| p.join("AssetData")));
         }
-        let bytes = std::fs::read(&path).ok()?;
-        let (index, family) = pick_face(&bytes, probe, hans)?;
-        log::debug!("interface CJK fallback: {family} ({})", path.display());
-        Some(SystemUiFont { family, bytes, index })
-    })
+        out.push(d);
+    }
+    out
 }
 
-/// The face of a font file (or collection) to use: one that maps `probe`, preferring a Regular
-/// style and, for Chinese, a Simplified Chinese family (`… SC`, `… GB`, as in a pan-CJK
-/// collection). `None` if the header isn't a font's or no face qualifies.
-pub(crate) fn pick_face(data: &[u8], probe: char, hans: bool) -> Option<(u32, String)> {
+/// The font file among `names` (tried in order, each in every folder of `dirs`) whose best face
+/// maps all of `needed`, or failing that the one mapping the most of them (the earliest on a
+/// tie). A file that maps none of them is never chosen.
+pub(crate) fn find_ui_font(dirs: &[std::path::PathBuf], names: &[&str], needed: &[char], hans: bool) -> Option<SystemUiFont> {
+    let mut tried = std::collections::HashSet::new();
+    let mut best: Option<(usize, SystemUiFont)> = None;
+    for path in names.iter().flat_map(|n| dirs.iter().map(move |d| d.join(n))) {
+        if !tried.insert(path.clone()) {
+            continue;
+        }
+        let Some(size) = std::fs::metadata(&path).ok().filter(|m| m.is_file()).map(|m| m.len()) else { continue };
+        if size > MAX_FILE {
+            continue;
+        }
+        let Ok(bytes) = std::fs::read(&path) else { continue };
+        let Some((index, family, covered)) = pick_face(&bytes, needed, hans) else { continue };
+        if best.as_ref().is_some_and(|(b, _)| *b >= covered) {
+            continue;
+        }
+        log::debug!("interface CJK fallback: {family} ({}), {covered} of {} characters", path.display(), needed.len());
+        best = Some((covered, SystemUiFont { family, bytes, index }));
+        if covered >= needed.len() {
+            break;
+        }
+    }
+    best.map(|(_, f)| f)
+}
+
+/// The face of a font file (or collection) to use and how many of `needed` it maps: the one
+/// mapping the most, then preferring a Regular style and, for Chinese, a Simplified Chinese
+/// family (`… SC`, `… GB`, as in a pan-CJK collection). `None` if the header isn't a font's or
+/// no face maps any of `needed`.
+pub(crate) fn pick_face(data: &[u8], needed: &[char], hans: bool) -> Option<(u32, String, usize)> {
     let magic = data.get(..4)?;
     if ![&[0, 1, 0, 0][..], b"OTTO", b"ttcf"].contains(&magic) {
         return None;
@@ -102,20 +180,22 @@ pub(crate) fn pick_face(data: &[u8], probe: char, hans: bool) -> Option<(u32, St
         FileRef::Font(_) => 1,
         FileRef::Collection(c) => c.len().min(MAX_FACES),
     };
-    let mut best: Option<((bool, bool), u32, String)> = None;
+    let mut best: Option<((usize, bool, bool), u32, String)> = None;
     for i in 0..count {
         let Ok(f) = skrifa::FontRef::from_index(data, i) else { continue };
-        if f.charmap().map(probe).is_none() {
+        let charmap = f.charmap();
+        let covered = needed.iter().filter(|c| charmap.map(**c).is_some()).count();
+        if covered == 0 {
             continue;
         }
         let Some((family, style, _)) = crate::fontdb::face_names(&f) else { continue };
         let regional = !hans || family.ends_with(" SC") || family.ends_with(" GB") || family.contains("YaHei");
-        let score = (style.eq_ignore_ascii_case("Regular"), regional);
+        let score = (covered, style.eq_ignore_ascii_case("Regular"), regional);
         if best.as_ref().is_none_or(|(s, ..)| score > *s) {
             best = Some((score, i, family));
         }
     }
-    best.map(|(_, i, family)| (i, family))
+    best.map(|((covered, ..), i, family)| (i, family, covered))
 }
 
 #[cfg(test)]
@@ -123,33 +203,55 @@ mod tests {
     use super::*;
 
     #[test]
-    fn needs_system_cjk_only_when_no_embedded_face_covers_the_language() {
-        let jp = CraftFont { family: "BIZ UDPGothic", style: "Regular", scripts: &["Jpan", "Latn"], bytes: &[] };
-        let sc = CraftFont { family: "Noto Sans CJK SC", style: "Regular", scripts: &["Hans", "Latn"], bytes: &[] };
-        // #241: the release embedded only the Japanese faces, and the Chinese interface fell back to them.
-        assert!(ui_needs_system_cjk(true, &[&jp]));
-        assert!(!ui_needs_system_cjk(true, &[&sc, &jp]));
-        assert!(!ui_needs_system_cjk(false, &[&jp]));
-        assert!(ui_needs_system_cjk(false, &[]));
-        assert!(ui_needs_system_cjk(true, &[]));
+    fn needs_system_cjk_when_an_embedded_face_lacks_an_interface_character() {
+        // A face without CJK glyphs stands in for a craft-fonts face that lacks some (#486).
+        let latin = CraftFont { family: "Source Sans 3", style: "Regular", scripts: &["Hans"], bytes: crate::bundled()[0] };
+        assert_eq!(ui_uncovered_cjk(&["选项 Options", "選項：选项"], &[&latin]), ['选', '選', '項', '项', '：']);
+        assert!(ui_needs_system_cjk(&["简体中文"], &[]));
+        assert!(ui_needs_system_cjk(&["Save", "开"], &[&latin]));
+        // Latin, Cyrillic and symbols are the Latin faces' business.
+        assert!(!ui_needs_system_cjk(&["Українська Español → ¶"], &[]));
+        // A damaged embedded face counts as covering nothing; it never panics.
+        let broken = CraftFont { family: "x", style: "Regular", scripts: &["Hans"], bytes: b"OTTO" };
+        assert!(ui_needs_system_cjk(&["页"], &[&broken]));
+        // The real faces, when built with craft-fonts: the Chinese face covers simplified and
+        // traditional hanzi the Japanese one lacks (#241, #486).
+        let embedded = crate::ui_cjk_fonts(true);
+        if crate::chinese_fonts().next().is_some() {
+            assert!(!ui_needs_system_cjk(&["页选项另存为啟內"], &embedded));
+        }
     }
 
     #[test]
-    fn finds_the_first_valid_font_covering_the_probe() {
+    fn finds_the_best_covering_font_also_in_macos_asset_folders() {
         let dir = std::env::temp_dir().join(format!("wc-uifallback-{}", std::process::id()));
         let _ = std::fs::remove_dir_all(&dir);
+        let assets = dir.join("com_apple_MobileAsset_Font7");
         std::fs::create_dir_all(dir.join("sub")).unwrap();
+        std::fs::create_dir_all(assets.join("0a1b.asset/AssetData")).unwrap();
+        std::fs::create_dir_all(assets.join("not-an-asset/AssetData")).unwrap();
         let sans = crate::bundled()[0];
         // Missing, damaged and non-font files are skipped without panicking.
         std::fs::write(dir.join("Deng.ttf"), b"ttcf\0\x01\0\0\xff\xff\xff\xff").unwrap();
         std::fs::write(dir.join("msyh.ttc"), b"<html>not a font</html>").unwrap();
         std::fs::write(dir.join("sub/good.ttf"), sans).unwrap();
         let names = ["missing.ttf", "Deng.ttf", "msyh.ttc", "sub/good.ttf"];
-        let found = find_ui_font(std::slice::from_ref(&dir), &names, 'A', true).unwrap();
+        let found = find_ui_font(std::slice::from_ref(&dir), &names, &['A'], true).unwrap();
         assert_eq!((found.family.as_str(), found.index, found.bytes.len()), ("Source Sans 3", 0, sans.len()));
         // No candidate maps a CJK character: nothing is chosen.
-        assert!(find_ui_font(std::slice::from_ref(&dir), &names, '页', true).is_none());
-        assert!(pick_face(b"OTT", 'A', false).is_none());
+        assert!(find_ui_font(std::slice::from_ref(&dir), &names, &['页'], true).is_none());
+        assert!(pick_face(b"OTT", &['A'], false).is_none());
+        // macOS 12 keeps PingFang in `AssetsV2/com_apple_MobileAsset_Font7/<hash>.asset/AssetData`.
+        std::fs::write(assets.join("0a1b.asset/AssetData/PingFang.ttc"), sans).unwrap();
+        std::fs::write(assets.join("not-an-asset/AssetData/Hidden.ttc"), sans).unwrap();
+        let dirs = with_asset_data(vec![dir.clone(), assets.clone()]);
+        assert_eq!(dirs, [dir.clone(), assets.join("0a1b.asset/AssetData"), assets.clone()]);
+        let found = find_ui_font(&dirs, &["PingFang.ttc"], &['A'], true).unwrap();
+        assert_eq!(found.family, "Source Sans 3");
+        assert!(find_ui_font(&dirs, &["Hidden.ttc"], &['A'], true).is_none());
+        // No file maps every needed character: the one mapping the most is used.
+        let found = find_ui_font(&dirs, &["sub/good.ttf", "PingFang.ttc"], &['A', '页'], true).unwrap();
+        assert_eq!(found.family, "Source Sans 3");
         let _ = std::fs::remove_dir_all(&dir);
     }
 }
diff --git a/crates/fonts/src/word.rs b/crates/fonts/src/word.rs
index b4461c0f81..66ef6a7ac0 100644
--- a/crates/fonts/src/word.rs
+++ b/crates/fonts/src/word.rs
@@ -36,6 +36,24 @@ fn substitutes(family: &str) -> &'static [&'static str] {
     // headings and screens. Open fonts with full Persian coverage first.
     const NASKH: &[&str] = &["Noto Naskh Arabic", "XB Zar", "XB Niloofar", "Amiri", "Vazirmatn", "Noto Sans Arabic", "DejaVu Sans", "Source Serif 4"];
     const ARABIC_SANS: &[&str] = &["Vazirmatn", "Sahel", "Shabnam", "Samim", "Noto Sans Arabic", "Noto Naskh Arabic", "DejaVu Sans", "Source Sans 3"];
+    // Palatino Linotype / Book Antiqua: macOS ships the same design as "Palatino"; open
+    // look-alikes with matching metrics (TeX Gyre Pagella, URW P052 / Palladio) on Linux.
+    const PALATINO: &[&str] = &[
+        "Palatino Linotype",
+        "Palatino",
+        "Book Antiqua",
+        "TeX Gyre Pagella",
+        "P052",
+        "URW Palladio L",
+        "Palladio",
+        "Caladea",
+        "Times New Roman",
+        "Liberation Serif",
+        "Georgia",
+        "Noto Serif",
+        "DejaVu Serif",
+        "Source Serif 4",
+    ];
     let f = family.to_ascii_lowercase();
     if is_persian_naskh(&f) {
         return NASKH;
@@ -44,6 +62,7 @@ fn substitutes(family: &str) -> &'static [&'static str] {
         return ARABIC_SANS;
     }
     match f.as_str() {
+        "palatino linotype" | "book antiqua" | "palatino" => PALATINO,
         "arial" | "helvetica" | "arial nova" => ARIAL,
         "times new roman" | "times" => TIMES,
         "courier new" | "courier" | "consolas" | "lucida console" | "cascadia code" | "cascadia mono" => MONO,
@@ -52,8 +71,6 @@ fn substitutes(family: &str) -> &'static [&'static str] {
         | "cambria math"
         | "georgia"
         | "garamond"
-        | "book antiqua"
-        | "palatino linotype"
         | "constantia"
         | "baskerville old face"
         | "century"
@@ -157,15 +174,24 @@ fn style_name(bold: bool, italic: bool) -> &'static str {
     }
 }
 
-/// Resolve `family` with bold/italic to a face (memoised).
+/// Resolve `family` with bold/italic to a face (memoised until user fonts are added or removed,
+/// [`FontDb::generation`]).
 pub fn resolve(family: &str, bold: bool, italic: bool) -> Resolved {
-    static CACHE: OnceLock<Mutex<HashMap<(String, bool, bool), Resolved>>> = OnceLock::new();
-    let cache = CACHE.get_or_init(|| Mutex::new(HashMap::new()));
-    let key = (family.to_string(), bold, italic);
-    if let Some(r) = cache.lock().unwrap_or_else(|e| e.into_inner()).get(&key) {
-        return *r;
-    }
+    type Memo = (u64, HashMap<(String, bool, bool), Resolved>);
+    static CACHE: OnceLock<Mutex<Memo>> = OnceLock::new();
+    let cache = CACHE.get_or_init(|| Mutex::new((0, HashMap::new())));
     let db = FontDb::global();
+    let generation = db.generation();
+    let key = (family.to_string(), bold, italic);
+    {
+        let mut c = cache.lock().unwrap_or_else(|e| e.into_inner());
+        if c.0 != generation {
+            *c = (generation, HashMap::new());
+        }
+        if let Some(r) = c.1.get(&key) {
+            return *r;
+        }
+    }
     let (fam, substituted) = if db.has_family(family) {
         (family.to_string(), false)
     } else {
@@ -174,7 +200,10 @@ pub fn resolve(family: &str, bold: bool, italic: bool) -> Resolved {
     };
     let face = db.face(&fam, style_name(bold, italic));
     let r = Resolved { synth_bold: bold && face.weight < 600.0, synth_italic: italic && !face.italic, substituted, face: FaceRef::of(&face) };
-    cache.lock().unwrap_or_else(|e| e.into_inner()).insert(key, r);
+    let mut c = cache.lock().unwrap_or_else(|e| e.into_inner());
+    if c.0 == generation {
+        c.1.insert(key, r);
+    }
     r
 }
 
@@ -206,9 +235,15 @@ pub fn symbol_font_char(family: &str, c: char) -> Option<char> {
     Some(u)
 }
 
+/// A line's (ascent, descent) from hhea values, both positive: the line gap goes above the ascent.
+fn hhea_line(ascender: i16, descender: i16, line_gap: i16) -> (f64, f64) {
+    (f64::from(ascender) + f64::from(line_gap.max(0)), f64::from(descender).abs())
+}
+
 /// Line metrics for a face in font units: (ascent, descent), both positive, the way word
-/// processors measure single line spacing (OS/2 usWinAscent/usWinDescent, falling back to the
-/// hhea values plus line gap).
+/// processors measure single line spacing: the hhea values with the line gap above the ascent
+/// (Word puts the first baseline that far below the line top), falling back to OS/2
+/// usWinAscent/usWinDescent.
 pub fn line_metrics(face: &crate::FontFace) -> (f64, f64) {
     static CACHE: OnceLock<Mutex<HashMap<u32, (f64, f64)>>> = OnceLock::new();
     let cache = CACHE.get_or_init(|| Mutex::new(HashMap::new()));
@@ -217,12 +252,9 @@ pub fn line_metrics(face: &crate::FontFace) -> (f64, f64) {
     }
     let mut v = (face.ascent.max(1.0), face.descent.abs());
     if let Some(f) = face.skrifa() {
-        // hhea ascender + descender + line gap (Word on macOS); OS/2 win metrics only when the
-        // hhea values are missing, and never more than twice the em.
-        let hhea = f.hhea().ok().map(|h| {
-            let gap = h.line_gap().to_i16().max(0) as f64;
-            (h.ascender().to_i16() as f64 + gap / 2.0, (h.descender().to_i16() as f64).abs() + gap / 2.0)
-        });
+        // hhea ascender + descender + line gap (Word on macOS), the gap above the ascent; OS/2
+        // win metrics only when the hhea values are missing, and never more than twice the em.
+        let hhea = f.hhea().ok().map(|h| hhea_line(h.ascender().to_i16(), h.descender().to_i16(), h.line_gap().to_i16()));
         let win = f.os2().ok().map(|o| (o.us_win_ascent() as f64, o.us_win_descent() as f64));
         let ok = |m: &(f64, f64)| m.0 > 0.0 && m.0 + m.1 <= face.upem * 2.0;
         if let Some(m) = hhea.filter(ok) {
@@ -239,6 +271,17 @@ pub fn line_metrics(face: &crate::FontFace) -> (f64, f64) {
 mod tests {
     use super::*;
 
+    #[test]
+    fn the_line_gap_goes_above_the_ascent() {
+        // Times New Roman (hhea 1825 / -443, gap 87), and a font with a large gap: Word puts the
+        // first baseline the ascent plus the whole gap below the line top.
+        assert_eq!(hhea_line(1825, -443, 87), (1912.0, 443.0));
+        assert_eq!(hhea_line(1536, -512, 452), (1988.0, 512.0));
+        // A negative gap adds nothing; the most negative descender doesn't overflow.
+        assert_eq!(hhea_line(1000, -300, -50), (1000.0, 300.0));
+        assert_eq!(hhea_line(1000, i16::MIN, 0), (1000.0, 32768.0));
+    }
+
     #[test]
     fn unknown_family_substitutes() {
         let r = resolve("Definitely Not A Font 123", false, false);
@@ -250,6 +293,19 @@ mod tests {
         assert!(a > 0.0 && d >= 0.0);
     }
 
+    #[test]
+    fn palatino_family_prefers_palatino_look_alikes_over_generic_serif() {
+        for name in ["Palatino Linotype", "Book Antiqua", "palatino"] {
+            let list = substitutes(name);
+            let pos = |n: &str| list.iter().position(|x| *x == n);
+            assert!(pos("Palatino").is_some() && pos("TeX Gyre Pagella").is_some() && pos("P052").is_some(), "{name}");
+            // All of them come before the generic serif fallbacks (Caladea, Times New Roman).
+            assert!(pos("Palatino") < pos("Caladea") && pos("TeX Gyre Pagella") < pos("Times New Roman"), "{name}");
+        }
+        // Other serif families are unchanged.
+        assert_eq!(substitutes("Georgia").first(), Some(&"Caladea"));
+    }
+
     #[test]
     fn symbol_font_chars_map_to_unicode() {
         assert_eq!(symbol_font_char("Symbol", '\u{F0B7}'), Some('\u{2022}'));
diff --git a/crates/formats/src/comments.rs b/crates/formats/src/comments.rs
new file mode 100644
index 0000000000..547440a51e
--- /dev/null
+++ b/crates/formats/src/comments.rs
@@ -0,0 +1,200 @@
+//! Print Markup for the text formats: HTML, Markdown and plain text copies end with the
+//! document's comments, numbered in document order, each with its author, the text it comments
+//! on, what it says and its replies (like the notes at the end of a printed document).
+
+use std::collections::{BTreeMap, HashMap, HashSet};
+
+use wordcraft_doc::para::{InlineObject, OBJ};
+use wordcraft_doc::{Document, StoryRef};
+
+/// Longest quoted anchor text (characters).
+const MAX_QUOTE: usize = 200;
+const MAX_COMMENTS: usize = 5_000;
+const MAX_REPLIES: usize = 200;
+const MAX_PARENT_CHAIN: usize = 64;
+
+/// One comment as written out.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct Note {
+    pub author: String,
+    /// The text it comments on (shortened), or empty.
+    pub quote: String,
+    pub text: String,
+    /// (author, text) of each reply, oldest first.
+    pub replies: Vec<(String, String)>,
+}
+
+fn root(doc: &Document, id: u32) -> u32 {
+    let mut cur = id;
+    for _ in 0..MAX_PARENT_CHAIN {
+        match doc.comments.get(&cur).and_then(|c| c.parent) {
+            Some(p) if p != cur && doc.comments.contains_key(&p) => cur = p,
+            _ => break,
+        }
+    }
+    cur
+}
+
+fn author(a: &str) -> String {
+    if a.trim().is_empty() { "Author".to_string() } else { a.trim().to_string() }
+}
+
+fn text_of(doc: &Document, part: u32) -> String {
+    doc.plain_text(StoryRef::Part(part)).split_whitespace().collect::<Vec<_>>().join(" ")
+}
+
+/// The document's top-level comments: those anchored in the body in document order, then the
+/// rest; replies go under the comment they answer.
+pub fn notes(doc: &Document) -> Vec<Note> {
+    if doc.comments.is_empty() {
+        return Vec::new();
+    }
+    // Anchor order and the text between each comment's start and end.
+    let mut order: Vec<u32> = Vec::new();
+    let mut seen = HashSet::new();
+    let mut quotes: HashMap<u32, String> = HashMap::new();
+    let mut open: Vec<u32> = Vec::new();
+    for path in doc.para_paths(StoryRef::Body) {
+        let Some(p) = doc.para(StoryRef::Body, &path) else { continue };
+        for (off, c) in p.text.char_indices() {
+            if c == OBJ {
+                match p.object_at(off) {
+                    Some(InlineObject::CommentStart { id }) => {
+                        if seen.insert(*id) {
+                            order.push(*id);
+                        }
+                        if !open.contains(id) && open.len() < 64 {
+                            open.push(*id);
+                        }
+                    }
+                    Some(InlineObject::CommentEnd { id }) => open.retain(|x| x != id),
+                    _ => {}
+                }
+                continue;
+            }
+            for id in &open {
+                let q = quotes.entry(*id).or_default();
+                if q.chars().count() <= MAX_QUOTE {
+                    q.push(c);
+                }
+            }
+        }
+        for id in &open {
+            quotes.entry(*id).or_default().push(' ');
+        }
+    }
+    for id in doc.comments.keys() {
+        if seen.insert(*id) {
+            order.push(*id);
+        }
+    }
+    let mut replies: BTreeMap<u32, Vec<u32>> = BTreeMap::new();
+    for id in doc.comments.keys() {
+        let r = root(doc, *id);
+        if r != *id {
+            let v = replies.entry(r).or_default();
+            if v.len() < MAX_REPLIES {
+                v.push(*id);
+            }
+        }
+    }
+    let mut out = Vec::new();
+    for id in order {
+        let Some(c) = doc.comments.get(&id) else { continue };
+        if root(doc, id) != id {
+            continue;
+        }
+        let quote = quotes.get(&id).map(|q| q.split_whitespace().collect::<Vec<_>>().join(" ")).unwrap_or_default();
+        let quote = if quote.chars().count() > MAX_QUOTE { format!("{}…", quote.chars().take(MAX_QUOTE).collect::<String>()) } else { quote };
+        let replies =
+            replies.get(&id).into_iter().flatten().filter_map(|r| doc.comments.get(r)).map(|r| (author(&r.author), text_of(doc, r.part))).collect();
+        out.push(Note { author: author(&c.author), quote, text: text_of(doc, c.part), replies });
+        if out.len() >= MAX_COMMENTS {
+            break;
+        }
+    }
+    out
+}
+
+/// `bytes` (a copy in format `ext`) with the comments written at its end.
+pub fn append(ext: &str, doc: &Document, bytes: Vec<u8>) -> Vec<u8> {
+    let notes = notes(doc);
+    if notes.is_empty() {
+        return bytes;
+    }
+    match ext {
+        "html" | "htm" | "xhtml" => {
+            let mut s = match String::from_utf8(bytes) {
+                Ok(s) => s,
+                Err(e) => return e.into_bytes(),
+            };
+            let at = s.rfind("</body>").unwrap_or(s.len());
+            s.insert_str(at, &html(&notes));
+            s.into_bytes()
+        }
+        "md" | "markdown" => {
+            let mut s = bytes;
+            s.extend_from_slice(markdown(&notes).as_bytes());
+            s
+        }
+        "txt" | "text" => {
+            let mut s = bytes;
+            s.extend_from_slice(text(&notes).as_bytes());
+            s
+        }
+        _ => bytes,
+    }
+}
+
+fn html(notes: &[Note]) -> String {
+    use crate::html::esc;
+    let mut s = String::from("<section class=\"comments\">\n<h2>Comments</h2>\n<ol>\n");
+    for (i, n) in notes.iter().enumerate() {
+        s.push_str(&format!("<li id=\"comment-{}\"><p><strong>{}</strong>", i + 1, esc(&n.author)));
+        if !n.quote.is_empty() {
+            s.push_str(&format!(" on <q>{}</q>", esc(&n.quote)));
+        }
+        s.push_str(&format!(": {}</p>", esc(&n.text)));
+        if !n.replies.is_empty() {
+            s.push_str("<ul>");
+            for (a, t) in &n.replies {
+                s.push_str(&format!("<li><strong>{}</strong>: {}</li>", esc(a), esc(t)));
+            }
+            s.push_str("</ul>");
+        }
+        s.push_str("</li>\n");
+    }
+    s.push_str("</ol>\n</section>\n");
+    s
+}
+
+fn markdown(notes: &[Note]) -> String {
+    use crate::markdown::escape;
+    let mut s = String::from("\n\n## Comments\n\n");
+    for (i, n) in notes.iter().enumerate() {
+        s.push_str(&format!("{}. **{}**", i + 1, escape(&n.author)));
+        if !n.quote.is_empty() {
+            s.push_str(&format!(" on “{}”", escape(&n.quote)));
+        }
+        s.push_str(&format!(": {}\n", escape(&n.text)));
+        for (a, t) in &n.replies {
+            s.push_str(&format!("    - **{}**: {}\n", escape(a), escape(t)));
+        }
+    }
+    s
+}
+
+fn text(notes: &[Note]) -> String {
+    let mut s = String::from("\r\n\r\nComments\r\n");
+    for (i, n) in notes.iter().enumerate() {
+        s.push_str(&format!("\r\n[{}] {}", i + 1, n.author));
+        if !n.quote.is_empty() {
+            s.push_str(&format!(" on “{}”", n.quote));
+        }
+        s.push_str(&format!(": {}\r\n", n.text));
+        for (a, t) in &n.replies {
+            s.push_str(&format!("    {a}: {t}\r\n"));
+        }
+    }
+    s
+}
diff --git a/crates/formats/src/html.rs b/crates/formats/src/html.rs
index 254b6c7ef5..afbee5ecdf 100644
--- a/crates/formats/src/html.rs
+++ b/crates/formats/src/html.rs
@@ -1004,9 +1004,7 @@ impl<'r> Builder<'r> {
                 }
             }
             "a" => {
-                if let Some(h) =
-                    attr(attrs, "href").filter(|h| !h.trim().is_empty() && !h.trim_start().to_ascii_lowercase().starts_with("javascript:"))
-                {
+                if let Some(h) = attr(attrs, "href").filter(|h| wordcraft_doc::link::is_safe_href(h)) {
                     fmt.link = Some(h.trim().to_string());
                 }
             }
@@ -1205,7 +1203,8 @@ pub fn inlines_html(inlines: &[Inline]) -> String {
             Inline::Text(t, f) => {
                 let mut open = String::new();
                 let mut close: Vec<&str> = Vec::new();
-                if let Some(l) = &f.link {
+                // A script or other non-web target is written as plain text (`is_safe_href`).
+                if let Some(l) = f.link.as_deref().filter(|l| wordcraft_doc::link::is_safe_href(l)) {
                     open.push_str(&format!("<a href=\"{}\">", esc(l)));
                     close.push("</a>");
                 }
diff --git a/crates/formats/src/lib.rs b/crates/formats/src/lib.rs
index d0aa5fd184..0c72e9ee8d 100644
--- a/crates/formats/src/lib.rs
+++ b/crates/formats/src/lib.rs
@@ -9,6 +9,7 @@
 //! depth-limited and sizes are capped.
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
+pub mod comments;
 pub mod html;
 pub mod latex;
 pub mod markdown;
@@ -55,5 +56,24 @@ pub fn export(ext: &str, doc: &Document) -> Option<Result<Vec<u8>, String>> {
     })
 }
 
+/// How [`export_with`] writes a copy.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct ExportOptions {
+    /// Print Markup: HTML, Markdown and plain text end with the document's comments (who wrote
+    /// each, the text it comments on, what it says, its replies). Other formats keep comments
+    /// their own way or not at all.
+    pub comments: bool,
+}
+
+/// [`export`] with options.
+pub fn export_with(ext: &str, doc: &Document, opts: &ExportOptions) -> Option<Result<Vec<u8>, String>> {
+    let out = export(ext, doc)?;
+    if !opts.comments {
+        return Some(out);
+    }
+    let ext = ext.trim_start_matches('.').to_ascii_lowercase();
+    Some(out.map(|bytes| comments::append(&ext, doc, bytes)))
+}
+
 #[cfg(test)]
 mod tests;
diff --git a/crates/formats/src/markdown.rs b/crates/formats/src/markdown.rs
index 76163918e0..0df3f5a571 100644
--- a/crates/formats/src/markdown.rs
+++ b/crates/formats/src/markdown.rs
@@ -1013,7 +1013,7 @@ fn emit(mut nodes: Vec<Node>) -> Vec<Inline> {
 // Export
 
 /// Escape text for Markdown (inline context).
-fn escape(s: &str) -> String {
+pub(crate) fn escape(s: &str) -> String {
     let mut out = String::with_capacity(s.len() + 8);
     for c in s.chars() {
         match c {
@@ -1125,8 +1125,9 @@ fn inlines_md(inlines: &[Inline]) -> String {
         }
     };
     for (text, f, raw) in pieces {
-        // Links are the outermost construct.
-        if f.link != link || raw.is_some() {
+        // Links are the outermost construct; a script or other non-web target is plain text.
+        let f_link = f.link.clone().filter(|l| wordcraft_doc::link::is_safe_href(l));
+        if f_link != link || raw.is_some() {
             close_all(&mut out, &mut stack);
             if let Some(l) = &link {
                 out.push_str(&format!("]({})", link_target(l)));
@@ -1136,9 +1137,9 @@ fn inlines_md(inlines: &[Inline]) -> String {
                 out.push_str(&r);
                 continue;
             }
-            if let Some(l) = &f.link {
+            if let Some(l) = f_link {
                 out.push('[');
-                link = Some(l.clone());
+                link = Some(l);
             }
         }
         let want: Vec<Mark> =
diff --git a/crates/formats/src/model.rs b/crates/formats/src/model.rs
index 03c5127673..9ca51775c5 100644
--- a/crates/formats/src/model.rs
+++ b/crates/formats/src/model.rs
@@ -509,7 +509,7 @@ impl Builder<'_> {
         }
         tb.rows.clear();
         for r in rows {
-            let mut row = wordcraft_doc::Row { props: RowProps::default(), cells: Vec::new() };
+            let mut row = wordcraft_doc::Row { props: RowProps::default(), cells: Vec::new(), controls: Default::default() };
             row.props.header = !r.is_empty() && r.iter().all(|c| c.header);
             let mut g = 0usize;
             for c in r.iter().take(wordcraft_doc::table::MAX_COLS) {
@@ -530,6 +530,7 @@ impl Builder<'_> {
                 row.cells.push(wordcraft_doc::Cell {
                     props: CellProps { width: Some(w), span: span as u32, vmerge, shading: c.shading, ..Default::default() },
                     blocks,
+                    controls: Default::default(),
                 });
             }
             if row.cells.is_empty() {
diff --git a/crates/formats/src/tests.rs b/crates/formats/src/tests.rs
index 889d8f2561..018ccc533e 100644
--- a/crates/formats/src/tests.rs
+++ b/crates/formats/src/tests.rs
@@ -280,6 +280,26 @@ fn txt_round_trip() {
     assert_eq!(import("txt", &[0x63, 0x61, 0x66, 0xE9, 0x80]).unwrap().unwrap().plain_text(Default::default()), "café€");
 }
 
+/// #569: a file with an extension we don't know opens as text when it is text (a playlist), and
+/// a binary file is told apart.
+#[test]
+fn text_sniffing() {
+    use crate::txt::is_text;
+    assert!(is_text(b""));
+    assert!(is_text(b"#EXTM3U\r\n#EXTINF:123,Artist - Title\r\nC:\\Music\\song.mp3\r\n"));
+    assert!(is_text("#EXTM3U\n#EXTINF:-1,Мелодия — ünïcødé\nhttp://x/y.mp3\n".as_bytes()));
+    assert!(is_text(&[0x23, 0x45, 0x58, 0x54, 0xE9, 0x0D, 0x0A, 0x1A])); // Windows-1252, DOS ^Z
+    assert!(is_text(&[0xEF, 0xBB, 0xBF, b'a']));
+    let u16le: Vec<u8> = "#EXTM3U\r\n".encode_utf16().flat_map(|u| u.to_le_bytes()).collect();
+    assert!(is_text(&u16le));
+    assert!(!is_text(b"\x89PNG\r\n\x1a\n\0\0\0\rIHDR"));
+    assert!(!is_text(b"PK\x03\x04\x14\0\x06\0"));
+    assert!(!is_text(b"%PDF-1.7\n%\xE2\xE3\xCF\xD3\n"));
+    assert!(!is_text(&[0x7F, b'E', b'L', b'F', 2, 1, 1, 3, 4, 5, 6, 7, 8]));
+    // Odd-length bytes with zeros mixed in: binary, not UTF-16.
+    assert!(!is_text(&[1, 0, 2, 0, 3]));
+}
+
 #[test]
 fn dispatch_unknown() {
     assert!(import("xyz", b"").is_none());
@@ -590,3 +610,47 @@ fn bounded_scans_keep_ordinary_markdown_and_entities() {
     let t = import("html", long.as_bytes()).unwrap().unwrap().plain_text(Default::default());
     assert!(t.contains(&"a".repeat(40)), "{t}");
 }
+
+/// A document's hyperlink can be `javascript:` (WordCraft refuses to follow it); the exported
+/// HTML and Markdown must not hand it to a browser either. Web, mail, bookmark and relative links
+/// still export as links.
+#[test]
+fn exported_links_keep_only_safe_targets() {
+    let links = [
+        ("script", "javascript:alert(1)"),
+        ("split", "java\nscript:alert(1)"),
+        ("vb", "vbscript:MsgBox(1)"),
+        ("data", "data:text/html,<b>x</b>"),
+        ("web", "https://ok.example/x"),
+        ("mail", "mailto:a@b.example"),
+        ("bookmark", "#top"),
+        ("relative", "other.html"),
+    ];
+    let mut d = Document::new();
+    let mut p = Paragraph::with_text("", CharProps::default());
+    for (text, l) in links {
+        let n = p.len();
+        p.insert_text(n, text, &CharProps { link: Some(l.to_string()), ..Default::default() }).unwrap();
+        let n = p.len();
+        p.insert_text(n, " ", &CharProps::default()).unwrap();
+    }
+    d.body = vec![para_block(p)];
+    let html = String::from_utf8(export("html", &d).unwrap().unwrap()).unwrap();
+    let md = String::from_utf8(export("md", &d).unwrap().unwrap()).unwrap();
+    for bad in ["javascript", "vbscript", "data:"] {
+        assert!(!html.to_ascii_lowercase().contains(bad), "html: {html}");
+        assert!(!md.to_ascii_lowercase().replace('\n', "").contains(bad), "md: {md}");
+    }
+    for (text, _) in links {
+        assert!(html.contains(text), "html keeps the text {text:?}: {html}");
+        assert!(md.contains(text), "md keeps the text {text:?}: {md}");
+    }
+    for (text, l) in &links[4..] {
+        assert!(html.contains(&format!("<a href=\"{l}\">{text}</a>")), "html: {html}");
+        assert!(md.contains(&format!("[{text}]({l})")), "md: {md}");
+    }
+    for text in ["script", "split", "vb", "data"] {
+        assert!(!html.contains(&format!(">{text}</a>")), "html: {html}");
+        assert!(!md.contains(&format!("[{text}](")), "md: {md}");
+    }
+}
diff --git a/crates/formats/src/txt.rs b/crates/formats/src/txt.rs
index c7dd7ddf16..0f85b3a1ea 100644
--- a/crates/formats/src/txt.rs
+++ b/crates/formats/src/txt.rs
@@ -13,6 +13,53 @@ fn utf16(b: &[u8], le: bool) -> String {
     String::from_utf16_lossy(&units)
 }
 
+/// UTF-16 without a BOM, told by its zero bytes: `Some(true)` little-endian, `Some(false)`
+/// big-endian.
+fn unmarked_utf16(b: &[u8]) -> Option<bool> {
+    if b.len() < 4 || !b.len().is_multiple_of(2) {
+        return None;
+    }
+    let sample = b.get(..b.len().min(512))?;
+    let even_zero = sample.iter().step_by(2).filter(|x| **x == 0).count();
+    let odd_zero = sample.iter().skip(1).step_by(2).filter(|x| **x == 0).count();
+    let half = sample.len() / 2;
+    if odd_zero * 10 >= half * 4 && even_zero * 10 < half {
+        return Some(true);
+    }
+    if even_zero * 10 >= half * 4 && odd_zero * 10 < half {
+        return Some(false);
+    }
+    None
+}
+
+/// Does `b` look like plain text, so a file with an extension WordCraft doesn't know (a
+/// playlist, a log, a config file…) can open as text the way Word's text import opens it?
+///
+/// Text has a BOM, or reads as UTF-16 by its zero bytes, or has no NUL byte and next to no
+/// other control characters in its first 64 KB. PDFs are refused by their signature (they
+/// start as text). An empty file is text.
+pub fn is_text(b: &[u8]) -> bool {
+    if b.starts_with(&[0xEF, 0xBB, 0xBF]) || b.starts_with(&[0xFF, 0xFE]) || b.starts_with(&[0xFE, 0xFF]) {
+        return true;
+    }
+    if b.starts_with(b"%PDF-") {
+        return false;
+    }
+    let sample = b.get(..b.len().min(64 << 10)).unwrap_or(b);
+    // Tab, line feed, form feed, carriage return, DOS end-of-file (^Z) and escape appear in text;
+    // other controls in more than 1 of 100 characters mean binary.
+    let odd = |c: u32| c == 0 || (c < 0x20 && !matches!(c, 0x09 | 0x0A | 0x0C | 0x0D | 0x1A | 0x1B)) || c == 0x7F;
+    if let Some(le) = unmarked_utf16(sample) {
+        let units = sample.as_chunks::<2>().0;
+        let n = units.iter().filter(|c| odd(u32::from(if le { u16::from_le_bytes(**c) } else { u16::from_be_bytes(**c) }))).count();
+        return n.saturating_mul(100) <= units.len();
+    }
+    if sample.contains(&0) {
+        return false;
+    }
+    sample.iter().filter(|c| odd(u32::from(**c))).count().saturating_mul(100) <= sample.len()
+}
+
 /// Decode text bytes: BOMs first, then UTF-16 without BOM (by its zero bytes), UTF-8, and
 /// Windows-1252 as the last resort.
 pub fn decode(b: &[u8]) -> String {
@@ -25,17 +72,8 @@ pub fn decode(b: &[u8]) -> String {
     if let Some(rest) = b.strip_prefix(&[0xFE, 0xFF]) {
         return utf16(rest, false);
     }
-    if b.len() >= 4 && b.len().is_multiple_of(2) {
-        let sample = &b[..b.len().min(512)];
-        let even_zero = sample.iter().step_by(2).filter(|x| **x == 0).count();
-        let odd_zero = sample.iter().skip(1).step_by(2).filter(|x| **x == 0).count();
-        let half = sample.len() / 2;
-        if odd_zero * 10 >= half * 4 && even_zero * 10 < half {
-            return utf16(b, true);
-        }
-        if even_zero * 10 >= half * 4 && odd_zero * 10 < half {
-            return utf16(b, false);
-        }
+    if let Some(le) = unmarked_utf16(b) {
+        return utf16(b, le);
     }
     match std::str::from_utf8(b) {
         Ok(s) => s.to_string(),
diff --git a/crates/layout/Cargo.toml b/crates/layout/Cargo.toml
index 913b430973..afb8f0a4a1 100644
--- a/crates/layout/Cargo.toml
+++ b/crates/layout/Cargo.toml
@@ -13,6 +13,7 @@ wordcraft-geom = { workspace = true }
 wordcraft-doc = { workspace = true }
 wordcraft-fonts = { workspace = true }
 wordcraft-proof = { workspace = true }
+kurbo = { workspace = true }
 unicode-bidi = { workspace = true }
 unicode-linebreak = { workspace = true }
 unicode-segmentation = { workspace = true }
diff --git a/crates/layout/src/balloons.rs b/crates/layout/src/balloons.rs
new file mode 100644
index 0000000000..026d4817db
--- /dev/null
+++ b/crates/layout/src/balloons.rs
@@ -0,0 +1,235 @@
+//! Print Markup: the comments in balloons in a markup area on the right of each page, joined to
+//! the text they comment on, the way Word prints and exports a document "showing markup".
+//!
+//! [`crate::layout`] calls [`add`] when [`crate::LayoutOptions::comment_balloons`] is on: each
+//! page grows by [`MARKUP_AREA`] ([`crate::Page::markup`]) and gets, for each comment anchored on
+//! it, a card (author colour stripe and border) holding the author's name and the comment's own
+//! laid-out text, with its replies under it, and a leader from the anchor to the card. The cards
+//! are ordinary placed items, so the PDF writer, the renderer and print draw them unchanged
+//! (the PDF writer scales each page down to its paper size). The editor draws its own interactive
+//! balloons instead.
+//!
+//! Hostile documents: comment, reply and parent-chain counts are capped; cards that don't fit
+//! are clipped to the page, and when a page has more comments than its markup area can hold the
+//! ones that find no room are left out.
+
+use std::collections::{BTreeMap, HashSet};
+
+use wordcraft_doc::para::InlineObject;
+use wordcraft_doc::props::{Border, BorderStyle, CharProps, Rgb, TextColor};
+use wordcraft_doc::{Document, Paragraph, Pos, StoryRef};
+use wordcraft_geom::Rect;
+
+use crate::display::revision_color;
+use crate::{BoxLayout, Ctx, DocLayout, Placed, fit_box, layout_box, push_para};
+
+/// Width of the markup area beside each page (points): the editor's.
+pub const MARKUP_AREA: f32 = 216.0;
+/// Space between the page and the cards, and on their right.
+const SIDE: f32 = 9.0;
+/// Space between cards.
+const GAP: f32 = 6.0;
+/// Padding inside a card.
+const PAD: f32 = 5.0;
+/// The author-colour stripe on a card's left.
+const STRIPE: f32 = 3.0;
+/// Space kept above the first and below the last card on a page.
+const EDGE: f32 = 12.0;
+/// Smallest card height when cards have to be clipped to fit a page.
+const MIN_CARD: f32 = 18.0;
+const MAX_BALLOONS: usize = 5_000;
+const MAX_REPLIES: usize = 200;
+const MAX_PARENT_CHAIN: usize = 64;
+
+/// Path given to the synthetic author-name paragraphs: no paragraph of the comment's story has it.
+const HEADER_PATH: u32 = u32::MAX;
+
+/// One comment's balloon before it is positioned: items relative to the card's top-left.
+struct Card {
+    page: usize,
+    /// The anchor: the comment's start, at the foot of its line.
+    ax: f32,
+    ay: f32,
+    items: Vec<Placed>,
+    h: f32,
+    color: Rgb,
+}
+
+/// The thread a comment belongs to: the comment at the top of its parent chain.
+fn root(doc: &Document, id: u32) -> u32 {
+    let mut cur = id;
+    for _ in 0..MAX_PARENT_CHAIN {
+        match doc.comments.get(&cur).and_then(|c| c.parent) {
+            Some(p) if p != cur && doc.comments.contains_key(&p) => cur = p,
+            _ => break,
+        }
+    }
+    cur
+}
+
+/// Each top-level comment anchored in the body, with where it starts, in document order. Replies
+/// have no balloon of their own: they go under the comment they answer.
+pub fn anchors(doc: &Document) -> Vec<(u32, Pos)> {
+    let mut seen = HashSet::new();
+    let mut out = Vec::new();
+    for path in doc.para_paths(StoryRef::Body) {
+        let Some(p) = doc.para(StoryRef::Body, &path) else { continue };
+        for off in p.object_offsets() {
+            let Some(InlineObject::CommentStart { id }) = p.object_at(off) else { continue };
+            if !doc.comments.contains_key(id) || root(doc, *id) != *id || !seen.insert(*id) {
+                continue;
+            }
+            out.push((*id, Pos { story: StoryRef::Body, path: path.clone(), off }));
+            if out.len() >= MAX_BALLOONS {
+                return out;
+            }
+        }
+    }
+    out
+}
+
+/// Replies by the top-level comment they belong to, oldest (lowest id) first.
+pub fn replies(doc: &Document) -> BTreeMap<u32, Vec<u32>> {
+    let mut m: BTreeMap<u32, Vec<u32>> = BTreeMap::new();
+    for id in doc.comments.keys() {
+        let r = root(doc, *id);
+        if r != *id {
+            let v = m.entry(r).or_default();
+            if v.len() < MAX_REPLIES {
+                v.push(*id);
+            }
+        }
+    }
+    m
+}
+
+/// The comment authors in order of first appearance (for their colours).
+fn author_index(doc: &Document, author: &str) -> u32 {
+    let mut seen: Vec<&str> = Vec::new();
+    for c in doc.comments.values() {
+        if !seen.contains(&c.author.as_str()) {
+            seen.push(&c.author);
+        }
+    }
+    seen.iter().position(|a| *a == author).unwrap_or(0) as u32
+}
+
+fn author_name(a: &str) -> &str {
+    if a.trim().is_empty() { "Author" } else { a }
+}
+
+/// Widen every page by the markup area and place the comment balloons in it.
+pub(crate) fn add(ctx: &mut Ctx, lay: &mut DocLayout) {
+    let doc = ctx.doc;
+    if doc.comments.is_empty() || lay.pages.is_empty() {
+        return;
+    }
+    let anchors = anchors(doc);
+    if anchors.is_empty() {
+        return;
+    }
+    let threads = replies(doc);
+    let card_w = MARKUP_AREA - 2.0 * SIDE;
+    let inner = card_w - STRIPE - 2.0 * PAD;
+    let mut cards: Vec<Card> = Vec::new();
+    for (id, pos) in anchors {
+        let Some(caret) = lay.caret_on(&pos, 0) else { continue };
+        let Some(c) = doc.comments.get(&id) else { continue };
+        let color = revision_color(author_index(doc, &c.author));
+        let mut thread = vec![id];
+        thread.extend(threads.get(&id).into_iter().flatten().copied());
+        let x = STRIPE + PAD;
+        let mut items = Vec::new();
+        let mut y = PAD;
+        for (k, cid) in thread.iter().enumerate() {
+            let Some(cm) = doc.comments.get(cid) else { continue };
+            let story = StoryRef::Part(cm.part);
+            if k > 0 {
+                // A reply starts: a hairline between it and what it answers.
+                y += 3.0;
+                let border = Border { style: BorderStyle::Single, width: 0.25, color: Some(Rgb(0xC8, 0xC8, 0xC8)), space: 0.0 };
+                items.push(Placed::Rule { x0: x, y0: y, x1: x + inner, y1: y, border });
+                y += 3.0;
+            }
+            // Who wrote it, in their colour.
+            let head = Paragraph::with_text(
+                author_name(&cm.author),
+                CharProps { bold: Some(true), size: Some(9.0), color: Some(TextColor::Rgb(color)), ..Default::default() },
+            );
+            let pl = ctx.para_labelled(&head, inner, None, &[], None);
+            let lead = pl.lines.first().map_or(0.0, |l| l.top.max(0.0));
+            push_para(&mut items, story, &[HEADER_PATH], &pl, 0, pl.lines.len(), x, y + lead, inner);
+            y += pl.height + 2.0;
+            // The comment itself, as written (its own formatting).
+            if let Some(part) = doc.parts.get(&cm.part) {
+                let BoxLayout { items: body, height, .. } = layout_box(ctx, story, &part.blocks, &[], inner, None, 1, None);
+                for mut it in body {
+                    it.translate(x, y);
+                    items.push(it);
+                }
+                y += height;
+            }
+        }
+        cards.push(Card { page: caret.page, ax: caret.x, ay: caret.top + caret.height, items, h: y + PAD, color });
+    }
+    // Every page gets the markup area, so the pages keep one size.
+    let widths: Vec<f32> = lay.pages.iter().map(|p| p.w).collect();
+    for p in &mut lay.pages {
+        p.w += MARKUP_AREA;
+        p.markup = MARKUP_AREA;
+    }
+    let mut by_page: BTreeMap<usize, Vec<Card>> = BTreeMap::new();
+    for c in cards {
+        by_page.entry(c.page).or_default().push(c);
+    }
+    for (pi, mut list) in by_page {
+        let (Some(page), Some(&pw)) = (lay.pages.get_mut(pi), widths.get(pi)) else { continue };
+        list.sort_by(|a, b| a.ay.total_cmp(&b.ay).then(a.ax.total_cmp(&b.ax)));
+        let (top_min, bottom) = (EDGE, (page.h - EDGE).max(EDGE + MIN_CARD));
+        // Each card as near its anchor as the ones above allow; then pushed up from the page
+        // foot; then down again below the top, clipping what still doesn't fit.
+        let mut tops: Vec<f32> = Vec::with_capacity(list.len());
+        let mut next = top_min;
+        for c in &list {
+            let t = (c.ay - 10.0).max(next);
+            tops.push(t);
+            next = t + c.h + GAP;
+        }
+        let mut limit = bottom;
+        for (t, c) in tops.iter_mut().zip(&list).rev() {
+            if *t + c.h > limit {
+                *t = limit - c.h;
+            }
+            limit = *t - GAP;
+        }
+        let mut next = top_min;
+        let x0 = pw + SIDE;
+        for (c, t) in list.into_iter().zip(tops) {
+            let top = t.max(next);
+            // No room left beside this page (dozens of comments on it): the rest are left out
+            // rather than drawn off the paper.
+            if top + MIN_CARD > bottom + 0.5 {
+                break;
+            }
+            let avail = bottom - top;
+            let (items, h) = if c.h > avail { (fit_box(c.items, avail - PAD), avail) } else { (c.items, c.h) };
+            next = top + h + GAP;
+            let line = |style, width: f32| Border { style, width, color: Some(c.color), space: 0.0 };
+            // Leader: along the text from the anchor to the page edge, then to the card.
+            page.items.push(Placed::Rule { x0: c.ax, y0: c.ay, x1: pw, y1: c.ay, border: line(BorderStyle::Dashed, 0.5) });
+            page.items.push(Placed::Rule { x0: pw, y0: c.ay, x1: x0, y1: top + 8.0, border: line(BorderStyle::Single, 0.5) });
+            // The card: white, outlined and striped in the author's colour.
+            let card = Rect::new(x0, top, card_w, h);
+            page.items.push(Placed::Fill { rect: card, color: Rgb(0xFF, 0xFF, 0xFF) });
+            page.items.push(Placed::Fill { rect: Rect::new(x0, top, STRIPE, h), color: c.color });
+            let (l, r, b) = (card.x, card.right(), card.bottom());
+            for (ax, ay, bx, by) in [(l, top, r, top), (r, top, r, b), (l, b, r, b), (l, top, l, b)] {
+                page.items.push(Placed::Rule { x0: ax, y0: ay, x1: bx, y1: by, border: line(BorderStyle::Single, 0.5) });
+            }
+            for mut it in items {
+                it.translate(x0, top);
+                page.items.push(it);
+            }
+        }
+    }
+}
diff --git a/crates/layout/src/display.rs b/crates/layout/src/display.rs
index 3b78b7f70b..48d1a50986 100644
--- a/crates/layout/src/display.rs
+++ b/crates/layout/src/display.rs
@@ -121,6 +121,15 @@ pub enum Draw {
         rect: Rect,
         items: Vec<Draw>,
     },
+    /// Text drawn from its outlines with WordArt effects (and bent, in a warped text box):
+    /// `path` in page coordinates, painted as [`crate::wordart::art_layers`] says. `color` is the
+    /// run's own colour, the fill when the effects set none.
+    Art {
+        path: BezPath,
+        fx: Box<wordcraft_doc::wordart::TextEffects>,
+        color: Rgb,
+        alpha: f32,
+    },
     /// A formatting-mark label (a section break's name) in the UI's mark colour, left edge at
     /// `x`, drawn with the same face as [`Draw::Mark`]. Screen only, like every mark.
     MarkText {
@@ -143,10 +152,40 @@ impl Draw {
     }
 }
 
+/// Formatting marks shown even while Show/Hide ¶ is off (File › Options › Display, "Always show
+/// these formatting marks"). Show/Hide ¶ on shows them all.
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]
+#[serde(default, rename_all = "camelCase")]
+pub struct FormattingMarks {
+    /// Tab characters (→).
+    pub tabs: bool,
+    /// Spaces (·).
+    pub spaces: bool,
+    /// Paragraph marks (¶), line breaks, page, column and section breaks.
+    pub paragraphs: bool,
+    /// Hidden text (shown with its dotted underline instead of left out).
+    pub hidden: bool,
+}
+
+impl FormattingMarks {
+    pub const ALL: FormattingMarks = FormattingMarks { tabs: true, spaces: true, paragraphs: true, hidden: true };
+
+    /// The marks on screen: all of them with Show/Hide ¶ on, else the chosen ones.
+    pub fn shown(self, show_all: bool) -> FormattingMarks {
+        if show_all { FormattingMarks::ALL } else { self }
+    }
+
+    pub fn any(self) -> bool {
+        self.tabs || self.spaces || self.paragraphs || self.hidden
+    }
+}
+
 #[derive(Clone, Debug)]
 pub struct DisplayOptions {
-    /// Show formatting marks (¶).
+    /// Show formatting marks (¶): Show/Hide ¶, every mark.
     pub marks: bool,
+    /// Marks shown while `marks` is off (File › Options › Display).
+    pub always: FormattingMarks,
     /// Dim headers/footers (editing the body) or the body (editing a header/footer).
     pub dim_header: bool,
     pub dim_body: bool,
@@ -164,6 +203,7 @@ impl Default for DisplayOptions {
     fn default() -> Self {
         DisplayOptions {
             marks: false,
+            always: FormattingMarks::default(),
             dim_header: true,
             dim_body: false,
             markup: true,
@@ -236,8 +276,11 @@ named! {
 named! {
     /// What the markup area beside the page shows.
     BalloonMode {
-        /// Deletions, formatting and comments in balloons (drawn like `CommentsAndFormatting`
-        /// for now: revisions stay inline).
+        /// Deletions, formatting and comments in balloons; insertions stay inline. Where the
+        /// editor shows balloons, deleted body text leaves the layout (`deletions_in_balloons`)
+        /// and the editor draws a "Deleted: …" balloon at its place; elsewhere (no markup area,
+        /// PDF, and headers, footers, notes and text boxes, which get no balloons) it is drawn
+        /// inline as in `CommentsAndFormatting`.
         Revisions = "revisions",
         /// Everything inline, no markup area.
         Inline = "inline",
@@ -320,14 +363,26 @@ pub fn page_display(doc: &Document, page: &Page, opts: &DisplayOptions) -> Vec<D
     let mut out = Vec::new();
     let ha = if opts.dim_header { 0.45 } else { 1.0 };
     let ba = if opts.dim_body { 0.45 } else { 1.0 };
-    for it in &page.header {
-        item(doc, it, opts, ha, &mut out);
-    }
-    for it in &page.footer {
-        item(doc, it, opts, ha, &mut out);
-    }
-    for it in &page.items {
-        item(doc, it, opts, ba, &mut out);
+    for (items, a) in [(&page.header, ha), (&page.footer, ha), (&page.items, ba)] {
+        let warps = warped_boxes(doc, items);
+        let mut done: Vec<u32> = Vec::new();
+        for it in items.iter() {
+            match it {
+                Placed::Lines { story: StoryRef::Part(id), .. } if warps.iter().any(|(w, ..)| w == id) => {
+                    // A warped text box's lines are drawn together, bent, where its first one is.
+                    if done.contains(id) {
+                        continue;
+                    }
+                    done.push(*id);
+                    if let Some((_, rect, warp)) = warps.iter().find(|(w, ..)| w == id) {
+                        let lines: Vec<&Placed> =
+                            items.iter().filter(|i| matches!(i, Placed::Lines { story: StoryRef::Part(s), .. } if s == id)).collect();
+                        warped_text(doc, &lines, *rect, warp, opts, a, &mut out);
+                    }
+                }
+                _ => item(doc, it, opts, a, &mut out),
+            }
+        }
     }
     if opts.markup && (opts.revisions.insertions_deletions || opts.revisions.formatting) && opts.revisions.changed_lines != ChangeBar::None {
         change_bars(doc, page, &opts.revisions, ba, &mut out);
@@ -335,6 +390,69 @@ pub fn page_display(doc: &Document, page: &Page, opts: &DisplayOptions) -> Vec<D
     out
 }
 
+/// The text boxes among `items` whose text is warped (Text Effects › Transform, drawn bent): their
+/// story, frame and warp. Empty, without a walk of the document, when none is.
+fn warped_boxes(doc: &Document, items: &[Placed]) -> Vec<(u32, Rect, wordcraft_doc::wordart::TextWarp)> {
+    items
+        .iter()
+        .filter_map(|it| {
+            let Placed::Object { rect, story, path, off, text_box: Some(id), .. } = it else { return None };
+            match doc.para(*story, path)?.object_at(*off)? {
+                InlineObject::Shape { extra, .. } => extra.warp.clone().filter(|w| !w.is_plain()).map(|w| (*id, *rect, w)),
+                _ => None,
+            }
+        })
+        .collect()
+}
+
+/// The text of a warped text box at `rect`: its lines' letters as outlines bent by `warp`, the
+/// box's text stretched over the frame inside its margins (as WordArt is). Underlines, marks and
+/// other decorations are left out; a warp that is drawn flat leaves the text as it is.
+fn warped_text(
+    doc: &Document,
+    lines: &[&Placed],
+    rect: Rect,
+    warp: &wordcraft_doc::wordart::TextWarp,
+    opts: &DisplayOptions,
+    alpha: f32,
+    out: &mut Vec<Draw>,
+) {
+    let mut raw = Vec::new();
+    for it in lines {
+        item(doc, it, opts, alpha, &mut raw);
+    }
+    // The letters: runs with effects as they are, plain runs from their glyphs.
+    let mut arts: Vec<(BezPath, Box<wordcraft_doc::wordart::TextEffects>, Rgb, f32)> = Vec::new();
+    let mut hidden = Vec::new();
+    for d in &raw {
+        match d {
+            Draw::Art { path, fx, color, alpha } => arts.push((path.clone(), fx.clone(), *color, *alpha)),
+            Draw::Glyphs { face, size, glyphs, color, alpha, synth_italic, .. } => {
+                if *alpha > 0.0 {
+                    arts.push((crate::wordart::glyph_path(face, *size, glyphs, *synth_italic), Box::default(), *color, *alpha));
+                }
+                let mut g = d.clone();
+                if let Draw::Glyphs { alpha, .. } = &mut g {
+                    *alpha = 0.0;
+                }
+                hidden.push(g);
+            }
+            _ => {}
+        }
+    }
+    let src = arts.iter().filter_map(|(p, ..)| crate::wordart::path_box(p)).reduce(|a, b| a.union(b));
+    let inset = Rect::new(rect.x + 7.2, rect.y + 3.6, (rect.w - 14.4).max(1.0), (rect.h - 7.2).max(1.0));
+    let fitted = src.and_then(|b| crate::wordart::Warp::new(warp, inset, (b.height() / b.width().max(1e-3)) as f32).map(|w| (b, w)));
+    let Some((src, w)) = fitted else {
+        out.extend(raw);
+        return;
+    };
+    for (path, fx, color, alpha) in arts {
+        out.push(Draw::Art { path: crate::wordart::warp_path(&path, src, &w), fx, color, alpha });
+    }
+    out.extend(hidden);
+}
+
 /// The automatic colour of the bars beside changed lines.
 pub const CHANGE_BAR: Rgb = Rgb(0x50, 0x50, 0x50);
 
@@ -422,9 +540,10 @@ fn item_in(doc: &Document, it: &Placed, opts: &DisplayOptions, alpha: f32, outer
         Placed::Image { rect, media, crop, spin, .. } => {
             spun(*spin, *rect, vec![Draw::Image { rect: *rect, media: media.clone(), crop: *crop, alpha }], out)
         }
-        Placed::Shape { rect, kind, fill, stroke, stroke_width, effects, freeform, spin } => {
+        Placed::Shape { rect, kind, fill, stroke, stroke_width, effects, freeform, spin, extra } => {
             let mut items = Vec::new();
-            shape_draws(*rect, *kind, *fill, *stroke, *stroke_width, effects_in(*effects, spin.within(outer)), freeform.as_deref(), opts, &mut items);
+            let fx = effects_in(*effects, spin.within(outer));
+            shape_draws(*rect, *kind, *fill, *stroke, *stroke_width, fx, freeform.as_deref(), extra, opts, &mut items);
             spun(*spin, *rect, items, out)
         }
         Placed::Graphic { rect, graphic, spin, .. } => spun(*spin, *rect, graphic_draws(doc, graphic, *rect, alpha), out),
@@ -445,6 +564,9 @@ fn item_in(doc: &Document, it: &Placed, opts: &DisplayOptions, alpha: f32, outer
                     *link = None;
                 }
             }
+            if *turn == TextDirection::Down {
+                items = upright_east_asian(items);
+            }
             out.push(Draw::Turned { x: *x, y: *y, turn: *turn, items });
         }
         Placed::Lines { story, path, para, l0, l1, x, y, .. } => lines(doc, *story, path, para, *l0, *l1, *x, *y, opts, alpha, out),
@@ -532,21 +654,24 @@ fn lines(
         // Label.
         if li == 0
             && let Some(lab) = &pl.label
-            && let Some(st) = pl.styles.get(lab.style as usize)
         {
             let gx = x + lab.x;
-            out.push(Draw::Glyphs {
-                face: st.face,
-                size: st.size,
-                glyphs: lab.glyphs.iter().map(|g| (g.gid, gx + g.dx, base - st.shift - g.dy)).collect(),
-                color: text_color(&st.rc.color, None),
-                alpha,
-                synth_bold: st.synth_bold,
-                synth_italic: st.synth_italic,
-                text: lab.text.clone(),
-                link: None,
-                ranges: Vec::new(),
-            });
+            // One draw per font run: a glyph id only means something in its own face.
+            for run in &lab.runs {
+                let Some(st) = pl.styles.get(run.style as usize) else { continue };
+                out.push(Draw::Glyphs {
+                    face: st.face,
+                    size: st.size,
+                    glyphs: lab.glyphs.get(run.glyphs.clone()).into_iter().flatten().map(|g| (g.gid, gx + g.dx, base - st.shift - g.dy)).collect(),
+                    color: text_color(&st.rc.color, None),
+                    alpha,
+                    synth_bold: st.synth_bold,
+                    synth_italic: st.synth_italic,
+                    text: run.text.clone(),
+                    link: None,
+                    ranges: Vec::new(),
+                });
+            }
         }
         // Hyphen at a hyphenated line end.
         if let Some((si, gid, adv)) = line.hyphen
@@ -696,13 +821,20 @@ fn lines(
                     g.0 = gid;
                 }
             }
+            // WordArt effects draw the letters from their outlines; the glyphs stay, invisible,
+            // for the PDF's text.
+            let art = rc.text_effects.as_ref().filter(|_| ins.is_none() && del.is_none() && !glyphs.is_empty());
+            if let Some(fx) = art {
+                let path = crate::wordart::glyph_path(&st.face, st.size, &glyphs, st.synth_italic);
+                out.push(Draw::Art { path, fx: fx.clone(), color, alpha });
+            }
             if !glyphs.is_empty() {
                 out.push(Draw::Glyphs {
                     face: st.face,
                     size: st.size,
                     glyphs,
                     color,
-                    alpha,
+                    alpha: if art.is_some() { 0.0 } else { alpha },
                     synth_bold: st.synth_bold || ins_mark == Some(InsertMark::Bold),
                     synth_italic: st.synth_italic || ins_mark == Some(InsertMark::Italic),
                     text,
@@ -883,7 +1015,8 @@ fn lines(
             }
         }
         // Formatting marks.
-        if opts.marks {
+        let marks = opts.always.shown(opts.marks);
+        if marks.any() {
             let msize = pl.styles.first().map(|s| s.size).unwrap_or(11.0);
             for k in line.c0..line.c1 {
                 let Some(c) = pl.clusters.get(k) else { continue };
@@ -892,14 +1025,14 @@ fn lines(
                 let size = pl.styles.get(c.style as usize).map(|s| s.size).unwrap_or(msize);
                 let arrow = if line.rtl { '←' } else { '→' };
                 match c.kind {
-                    ClKind::Space => {
+                    ClKind::Space if marks.spaces => {
                         out.push(Draw::Mark { x: (cx + nx) / 2.0 - size * 0.12, baseline: base - size * 0.08, size, ch: '·', color: None })
                     }
-                    ClKind::Tab => {
+                    ClKind::Tab if marks.tabs => {
                         out.push(Draw::Mark { x: cx + ((nx - cx) / 2.0 - size * 0.3).max(0.0), baseline: base, size, ch: arrow, color: None })
                     }
-                    ClKind::LineBreak => out.push(Draw::Mark { x: cx + 1.0, baseline: base, size, ch: '↵', color: None }),
-                    ClKind::PageBreak | ClKind::ColumnBreak => {
+                    ClKind::LineBreak if marks.paragraphs => out.push(Draw::Mark { x: cx + 1.0, baseline: base, size, ch: '↵', color: None }),
+                    ClKind::PageBreak | ClKind::ColumnBreak if marks.paragraphs => {
                         let label = if c.kind == ClKind::PageBreak { '⤓' } else { '⇥' };
                         out.push(Draw::Line {
                             x0: cx + 2.0,
@@ -916,7 +1049,7 @@ fn lines(
                     _ => {}
                 }
             }
-            if line.end == LineEnd::Para {
+            if line.end == LineEnd::Para && marks.paragraphs {
                 // The mark follows the line's visual end, past every glyph, even where the
                 // logically last text runs against the paragraph's direction.
                 let ex = x + line.visual_end_x();
@@ -1128,9 +1261,14 @@ fn shape_draws(
     stroke_width: f32,
     effects: wordcraft_doc::effects::ShapeEffects,
     freeform: Option<&wordcraft_doc::freeform::Freeform>,
+    extra: &wordcraft_doc::connector::ShapeExtra,
     opts: &DisplayOptions,
     out: &mut Vec<Draw>,
 ) {
+    if kind.is_open() {
+        line_draws(rect, kind, stroke, stroke_width, effects, extra, out);
+        return;
+    }
     let Some(f) = freeform.filter(|_| kind == ShapeKind::Freeform) else {
         out.push(Draw::Shape { rect, kind, fill, stroke, stroke_width, effects });
         return;
@@ -1161,6 +1299,52 @@ fn shape_draws(
     }
 }
 
+/// A line or connector at `rect` (its unflipped frame: flips are the frame's turn), with its
+/// arrowheads.
+fn line_draws(
+    rect: Rect,
+    kind: ShapeKind,
+    stroke: Option<Rgb>,
+    stroke_width: f32,
+    effects: wordcraft_doc::effects::ShapeEffects,
+    extra: &wordcraft_doc::connector::ShapeExtra,
+    out: &mut Vec<Draw>,
+) {
+    use wordcraft_doc::connector::{connector_segs, end_direction};
+    match connector_segs(kind, rect.w, rect.h) {
+        Some(segs) => {
+            let segs = segs
+                .into_iter()
+                .map(|s| match s {
+                    PathSeg::Move(x, y) => PathSeg::Move(rect.x + x, rect.y + y),
+                    PathSeg::Line(x, y) => PathSeg::Line(rect.x + x, rect.y + y),
+                    PathSeg::Cubic(a, b, c, d, e, f) => PathSeg::Cubic(rect.x + a, rect.y + b, rect.x + c, rect.y + d, rect.x + e, rect.y + f),
+                    PathSeg::Close => PathSeg::Close,
+                })
+                .collect();
+            out.push(Draw::Path { segs, fill: None, stroke, stroke_width });
+        }
+        None => out.push(Draw::Shape { rect, kind, fill: None, stroke, stroke_width, effects }),
+    }
+    let Some(color) = stroke else { return };
+    // Our line runs from the bottom-left corner to the top-right; connectors from the top-left
+    // to the bottom-right.
+    let (start, end) =
+        if kind == ShapeKind::Line { ((rect.x, rect.bottom()), (rect.right(), rect.y)) } else { ((rect.x, rect.y), (rect.right(), rect.bottom())) };
+    let width = if stroke_width.is_finite() { stroke_width.clamp(0.25, 200.0) } else { 0.75 };
+    let len = (width * 3.5).max(7.0);
+    for (on, tip, at_end) in [(extra.arrow_start, start, false), (extra.arrow_end, end, true)] {
+        if !on {
+            continue;
+        }
+        let (dx, dy) = end_direction(kind, rect.w, rect.h, at_end);
+        let (bx, by) = (tip.0 - dx * len, tip.1 - dy * len);
+        let (nx, ny) = (-dy * len * 0.45, dx * len * 0.45);
+        let segs = vec![PathSeg::Move(tip.0, tip.1), PathSeg::Line(bx + nx, by + ny), PathSeg::Line(bx - nx, by - ny), PathSeg::Close];
+        out.push(Draw::Path { segs, fill: Some(color), stroke: None, stroke_width: 0.0 });
+    }
+}
+
 pub fn seg_path(segs: &[PathSeg]) -> BezPath {
     let mut p = BezPath::new();
     for s in segs {
@@ -1260,10 +1444,10 @@ fn object_draws(o: &InlineObject, rect: Rect, outer: Spin, alpha: f32, opts: &Di
     let own = o.frame().map(|(_, _, f)| f.spin()).unwrap_or_default();
     match o {
         InlineObject::Image { media, crop, .. } => spun(own, rect, vec![Draw::Image { rect, media: media.clone(), crop: *crop, alpha }], out),
-        InlineObject::Shape { kind, fill, stroke, stroke_width, effects, freeform, .. } => {
+        InlineObject::Shape { kind, fill, stroke, stroke_width, effects, freeform, extra, .. } => {
             let effects = effects_in(*effects, own.within(outer));
             let mut items = Vec::new();
-            shape_draws(rect, *kind, *fill, *stroke, *stroke_width, effects, freeform.as_deref(), opts, &mut items);
+            shape_draws(rect, *kind, *fill, *stroke, *stroke_width, effects, freeform.as_deref(), extra, opts, &mut items);
             spun(own, rect, items, out)
         }
         InlineObject::Group { .. } => {
@@ -1315,3 +1499,90 @@ pub(crate) fn inline_rect(obj: Option<&InlineObject>, cx: f32, base: f32, adv: f
 fn canvas_background(rect: Rect, c: &wordcraft_doc::para::CanvasStyle) -> Draw {
     Draw::Shape { rect, kind: ShapeKind::Rectangle, fill: c.fill, stroke: c.stroke, stroke_width: c.stroke_width, effects: Default::default() }
 }
+
+/// Whether `c` stands upright in top-to-bottom East Asian text (`tbRl`) rather than turning with
+/// the line: ideographs, kana, Hangul, full-width letters and digits, and the ideographic comma
+/// and full stop (an approximation of Unicode's vertical orientation, UAX #50). Brackets, dashes
+/// and the prolonged sound mark turn with the line, as their vertical forms do.
+pub fn upright_in_vertical(c: char) -> bool {
+    matches!(c,
+        '\u{1100}'..='\u{11FF}'
+        | '\u{2E80}'..='\u{2FFF}'
+        | '\u{3001}'..='\u{3007}'
+        | '\u{3012}'..='\u{3013}'
+        | '\u{3020}'..='\u{302F}'
+        | '\u{3031}'..='\u{303F}'
+        | '\u{3040}'..='\u{30FB}'
+        | '\u{30FD}'..='\u{30FF}'
+        | '\u{3100}'..='\u{31EF}'
+        | '\u{31F0}'..='\u{4DBF}'
+        | '\u{4E00}'..='\u{9FFF}'
+        | '\u{A960}'..='\u{A97F}'
+        | '\u{AC00}'..='\u{D7FF}'
+        | '\u{F900}'..='\u{FAFF}'
+        | '\u{FE30}'..='\u{FE4F}'
+        | '\u{FF01}'..='\u{FF07}'
+        | '\u{FF0A}'..='\u{FF0C}'
+        | '\u{FF0E}'..='\u{FF3A}'
+        | '\u{FF3C}'
+        | '\u{FF3E}'..='\u{FF5A}'
+        | '\u{FFE0}'..='\u{FFE6}'
+        | '\u{20000}'..='\u{3FFFF}'
+    )
+}
+
+/// Top-to-bottom text drawn turned 90° clockwise, with its East Asian characters turned back
+/// upright, each about the centre of its em square (`tbRl`: ideographs stand, Latin lies).
+/// Glyph runs are split where uprightness changes, so the text keeps its order.
+fn upright_east_asian(items: Vec<Draw>) -> Vec<Draw> {
+    let mut out = Vec::with_capacity(items.len());
+    for d in items {
+        let Draw::Glyphs { face, size, glyphs, color, alpha, synth_bold, synth_italic, text, link, ranges } = d else {
+            out.push(d);
+            continue;
+        };
+        let up = |k: usize| ranges.get(k).and_then(|r| text.get(r.clone())).and_then(|t| t.chars().next()).is_some_and(upright_in_vertical);
+        if ranges.len() != glyphs.len() || !(0..glyphs.len()).any(up) {
+            out.push(Draw::Glyphs { face, size, glyphs, color, alpha, synth_bold, synth_italic, text, link, ranges });
+            continue;
+        }
+        let piece = |k0: usize, k1: usize| -> Draw {
+            let gs = glyphs.get(k0..k1).unwrap_or(&[]).to_vec();
+            let rs = ranges.get(k0..k1).unwrap_or(&[]);
+            let (b0, b1) = (rs.iter().map(|r| r.start).min().unwrap_or(0), rs.iter().map(|r| r.end).max().unwrap_or(0));
+            let t = text.get(b0..b1).unwrap_or("").to_string();
+            let rs = rs.iter().map(|r| r.start.saturating_sub(b0)..r.end.saturating_sub(b0)).collect();
+            Draw::Glyphs { face, size, glyphs: gs, color, alpha, synth_bold, synth_italic, text: t, link: link.clone(), ranges: rs }
+        };
+        let mut k0 = 0;
+        while k0 < glyphs.len() {
+            let u = up(k0);
+            let k1 = (k0 + 1..glyphs.len()).find(|&k| up(k) != u).unwrap_or(glyphs.len());
+            if !u {
+                out.push(piece(k0, k1));
+            } else {
+                for k in k0..k1 {
+                    let Some(&(_, gx, base)) = glyphs.get(k) else { continue };
+                    // The em square: one em along the line (the advance to the next glyph when
+                    // known), from about 0.88 em above the baseline to 0.12 em below it.
+                    let adv = glyphs.get(k + 1).map(|g| g.1 - gx).filter(|a| *a > 0.0 && *a < size * 2.0).unwrap_or(size);
+                    let (cx, cy) = (gx + adv / 2.0, base - size * 0.38);
+                    let mut g = piece(k, k + 1);
+                    // The ideographic comma and full stop sit in the upper right of their square in
+                    // vertical text (lower left in horizontal): moved there before standing up.
+                    if let Draw::Glyphs { text, glyphs, .. } = &mut g
+                        && matches!(text.chars().next(), Some('\u{3001}' | '\u{3002}' | '\u{FF0C}' | '\u{FF0E}'))
+                    {
+                        for (_, x, y) in glyphs.iter_mut() {
+                            *x += size * 0.55;
+                            *y -= size * 0.55;
+                        }
+                    }
+                    out.push(Draw::Rotated { cx, cy, spin: Spin::new(-90.0, false, false), items: vec![g] });
+                }
+            }
+            k0 = k1;
+        }
+    }
+    out
+}
diff --git a/crates/layout/src/fields.rs b/crates/layout/src/fields.rs
index e703f8dd8c..b2d516fd72 100644
--- a/crates/layout/src/fields.rs
+++ b/crates/layout/src/fields.rs
@@ -55,7 +55,7 @@ pub fn field_name(instr: &str) -> String {
 }
 
 /// `\* FORMAT` switch value (Arabic, roman, ROMAN, alphabetic, ALPHABETIC, CardText, Ordinal…).
-fn format_switch(instr: &str) -> Option<NumFormat> {
+pub fn format_switch(instr: &str) -> Option<NumFormat> {
     let mut it = instr.split_whitespace();
     while let Some(w) = it.next() {
         if w == "\\*" {
@@ -69,6 +69,10 @@ fn format_switch(instr: &str) -> Option<NumFormat> {
                 "OrdText" | "ordtext" => NumFormat::OrdinalText,
                 "Ordinal" | "ordinal" => NumFormat::Ordinal,
                 "Arabic" | "arabic" => NumFormat::Decimal,
+                // Chinese numerals: counting (一百零一), legal (壹佰零壹), digit by digit (一〇一).
+                v if v.eq_ignore_ascii_case("ChineseNum1") => NumFormat::ChineseCountingThousand,
+                v if v.eq_ignore_ascii_case("ChineseNum2") => NumFormat::ChineseLegalSimplified,
+                v if v.eq_ignore_ascii_case("ChineseNum3") => NumFormat::IdeographDigital,
                 _ => continue,
             });
         }
@@ -110,6 +114,8 @@ mod tests {
         assert_eq!(field_text("PAGE", "", &ctx), ("4".into(), true));
         assert_eq!(field_text(" PAGE \\* ROMAN ", "", &ctx).0, "IV");
         assert_eq!(field_text("NUMPAGES \\* CardText", "", &ctx).0, "Twelve");
+        assert_eq!(field_text("NUMPAGES \\* CHINESENUM1", "", &ctx).0, "十二");
+        assert_eq!(field_text("PAGE \\* ChineseNum2", "", &ctx).0, "肆");
         assert_eq!(field_text("DATE \\@ \"M/d/yyyy\"", "1/2/2026", &ctx), ("1/2/2026".into(), false));
         assert_eq!(field_name("=SUM(ABOVE)"), "SUM(ABOVE)");
         assert_eq!(field_code_text(" PAGE \\* ROMAN "), "{ PAGE \\* ROMAN }");
diff --git a/crates/layout/src/hit.rs b/crates/layout/src/hit.rs
index db8fab9c4c..53c10d7644 100644
--- a/crates/layout/src/hit.rs
+++ b/crates/layout/src/hit.rs
@@ -137,6 +137,25 @@ fn items_of(page: &Page, story: StoryRef) -> Box<dyn Iterator<Item = &Placed> +
     }
 }
 
+/// Whether header/footer part `id` has text near (x, y) on the page (its header or footer
+/// lines). Used so an object behind the header text is only grabbed where there's no text,
+/// mirroring `text_at` for the body.
+fn hf_text_at(p: &Page, id: u32, x: f32, y: f32) -> bool {
+    let story = StoryRef::Part(id);
+    p.header
+        .iter()
+        .chain(p.footer.iter())
+        .filter_map(|it| match it {
+            Placed::Lines { story: s, para, l0, l1, x: lx, y: ly, .. } if *s == story => Some((para, l0, l1, lx, ly)),
+            _ => None,
+        })
+        .any(|(para, l0, l1, lx, ly)| {
+            let (Some(first), Some(last)) = (para.lines.get(*l0), para.lines.get(l1.checked_sub(1).unwrap_or(0))) else { return false };
+            let bottom = ly + last.top + last.height - first.top;
+            y >= *ly - 2.0 && y <= bottom + 2.0 && x >= *lx - 40.0 && x <= lx + last.right + 40.0
+        })
+}
+
 /// Every upright line on a page that belongs to `story` (body, or a header/footer part).
 /// Turned lines (see [`turned_hit`]) are left out.
 pub fn page_lines(page: &Page, story: StoryRef) -> Vec<LineHit<'_>> {
@@ -176,6 +195,24 @@ fn turned_hit(page: &Page, story: StoryRef, x: f32, y: f32) -> Option<Pos> {
     })
 }
 
+/// The position in the turned text of `story` nearest to page point (x, y), wherever it is.
+fn nearest_turned(page: &Page, story: StoryRef, x: f32, y: f32) -> Option<Pos> {
+    let dist = |r: Rect| band_dist(x, r.x, r.w).hypot(band_dist(y, r.y, r.h));
+    let it = items_of(page, story)
+        .filter(|it| matches!(it, Placed::Lines { story: s, .. } if *s == story))
+        .filter_map(|it| it.turned_bounds().map(|r| (it, dist(r))))
+        .min_by(|a, b| a.1.total_cmp(&b.1))?
+        .0;
+    let Placed::Lines { path, para, l0, l1, x: ox, y: oy, turn, .. } = it else { return None };
+    let (u, v) = crate::unturn_point(*turn, *ox, *oy, x, y);
+    let first = para.lines.get(*l0)?;
+    let li = (*l0..*l1)
+        .filter_map(|li| para.lines.get(li).map(|l| (li, l.top - first.top, l.height)))
+        .min_by(|a, b| band_dist(v, a.1, a.2).total_cmp(&band_dist(v, b.1, b.2)))?
+        .0;
+    Some(Pos { story, path: path.clone(), off: para.off_at_x(li, u) })
+}
+
 /// How far `v` is outside the band `top..top + h`.
 fn band_dist(v: f32, top: f32, h: f32) -> f32 {
     if v < top {
@@ -195,6 +232,10 @@ impl DocLayout {
             return Some(pos);
         }
         let lines = page_lines(p, story);
+        if lines.is_empty() {
+            // A page of turned text (a vertical section): the nearest turned line.
+            return nearest_turned(p, story, x, y);
+        }
         let best = lines.iter().min_by(|a, b| score(a, x, y).total_cmp(&score(b, x, y)))?;
         let off = best.para.off_at_x(best.li, x - best.x);
         Some(Pos { story: best.story, path: best.path.clone(), off })
@@ -215,15 +256,32 @@ impl DocLayout {
     /// border (within `edge` points either side; inside is its text). Topmost first; objects
     /// behind the text only where there's no text.
     pub fn object_at(&self, page: usize, x: f32, y: f32, edge: f32) -> Option<ObjectHit> {
+        self.object_at_in(page, x, y, edge, StoryRef::Body)
+    }
+
+    /// The object of `story` a press at (x, y) grabs. Body looks only at the page's own items
+    /// (as before); a header/footer part looks only at that part's objects in the page's
+    /// header and footer, so a header picture placed over the body never steals body clicks.
+    pub fn object_at_in(&self, page: usize, x: f32, y: f32, edge: f32, story: StoryRef) -> Option<ObjectHit> {
         let p = self.pages.get(page)?;
         // A rotated object is grabbed on its rotated shape: the point is taken into its frame.
         let grabs = |o: &ObjectHit| {
             let pt = o.unspin(x, y);
             o.rect.expand(edge).contains(pt) && (o.text_box.is_none() || !o.rect.expand(-edge).contains(pt) || o.rect.w.min(o.rect.h) <= edge * 3.0)
         };
-        objects(p, page)
+        let cands: Vec<ObjectHit> = match story {
+            StoryRef::Body => objects(p, page).collect(),
+            StoryRef::Part(_) => all_objects(p, page).filter(|o| o.story == story).collect(),
+        };
+        let text_here = match story {
+            StoryRef::Body => text_at(p, page, x, y).is_some(),
+            StoryRef::Part(id) => hf_text_at(p, id, x, y),
+        };
+        cands
+            .iter()
             .find(|o| !o.behind() && grabs(o))
-            .or_else(|| if text_at(p, page, x, y).is_some() { None } else { objects(p, page).find(|o| o.behind() && grabs(o)) })
+            .or_else(|| if text_here { None } else { cands.iter().find(|o| o.behind() && grabs(o)) })
+            .cloned()
     }
 
     /// The text box in the header or footer at (x, y) on `page`.
@@ -280,18 +338,49 @@ impl DocLayout {
             order.insert(0, page_hint);
         }
         for pi in order {
-            let Some(p) = self.pages.get(pi) else { continue };
-            let found: Vec<(usize, &Placed)> = items_of(p, story)
-                .filter(|it| matches!(it, Placed::Lines { story: s, path: q, .. } if *s == story && q == path))
-                .map(|it| (pi, it))
-                .collect();
-            if !found.is_empty() {
-                return found;
+            let mut found = self.pieces_on(pi, story, path);
+            if found.is_empty() {
+                continue;
             }
+            // A note continued over pages has the rest of the paragraph on the pages before or
+            // after (a repeated header shows all of it on every page: one page is enough).
+            let lines = |v: &[(usize, &Placed)]| {
+                v.iter()
+                    .filter_map(|(_, it)| if let Placed::Lines { para, l0, l1, .. } = it { Some((*l0, *l1, para.lines.len())) } else { None })
+                    .fold((usize::MAX, 0, 0), |(a, b, _), (l0, l1, n)| (a.min(l0), b.max(l1), n))
+            };
+            let (mut lo, mut hi, n) = lines(&found);
+            let mut k = pi;
+            while lo > 0 && k > 0 {
+                k -= 1;
+                let more = self.pieces_on(k, story, path);
+                if more.is_empty() {
+                    break;
+                }
+                lo = lo.min(lines(&more).0);
+                found.extend(more);
+            }
+            let mut k = pi;
+            while hi < n && k + 1 < self.pages.len() {
+                k += 1;
+                let more = self.pieces_on(k, story, path);
+                if more.is_empty() {
+                    break;
+                }
+                hi = hi.max(lines(&more).1);
+                found.extend(more);
+            }
+            return found;
         }
         Vec::new()
     }
 
+    /// Pieces of a paragraph of story part `story` on page `pi`.
+    fn pieces_on(&self, pi: usize, story: StoryRef, path: &Path) -> Vec<(usize, &Placed)> {
+        let Some(p) = self.pages.get(pi) else { return Vec::new() };
+        items_of(p, story).filter(|it| matches!(it, Placed::Lines { story: s, path: q, .. } if *s == story && q == path)).map(|it| (pi, it)).collect()
+    }
+
     /// Caret geometry for a position.
     pub fn caret(&self, pos: &Pos) -> Option<Caret> {
         self.caret_on(pos, 0)
@@ -566,7 +655,7 @@ impl DocLayout {
     pub fn cell_at(&self, page: usize, x: f32, y: f32) -> Option<(StoryRef, Path, usize, usize)> {
         let p = self.pages.get(page)?;
         p.items.iter().rev().find_map(|it| match it {
-            Placed::Cell { rect, table, row, cell, story } if rect.contains(wordcraft_geom::Point::new(x, y)) => {
+            Placed::Cell { rect, table, row, cell, story, covered: false } if rect.contains(wordcraft_geom::Point::new(x, y)) => {
                 Some((*story, table.clone(), *row, *cell))
             }
             _ => None,
diff --git a/crates/layout/src/lib.rs b/crates/layout/src/lib.rs
index af8e9e4206..3b13445408 100644
--- a/crates/layout/src/lib.rs
+++ b/crates/layout/src/lib.rs
@@ -8,15 +8,19 @@
 //! - [`hit`]: point ↔ position, caret geometry, line navigation, selection rectangles.
 #![deny(clippy::unwrap_used, clippy::expect_used, clippy::panic, clippy::unimplemented, clippy::todo, clippy::unreachable)]
 
+pub mod balloons;
 mod contour;
 pub mod display;
 pub mod fields;
 pub mod hit;
 pub mod kinsoku;
 pub mod math;
+pub mod outline;
 pub mod para;
 mod table;
 mod textbox;
+mod vertical;
+pub mod wordart;
 
 use std::collections::{HashMap, HashSet};
 use std::hash::{Hash, Hasher};
@@ -25,7 +29,7 @@ use std::sync::Arc;
 use wordcraft_doc::numbering::{Counters, Level};
 use wordcraft_doc::para::{Anchor, Float, FloatAlign, InlineObject, Wrap, WrapText};
 use wordcraft_doc::props::{Border, CharProps, Rgb, TableFloat, TextDirection};
-use wordcraft_doc::section::{SectionProps, SectionStart};
+use wordcraft_doc::section::{HeaderSet, SectionProps, SectionStart};
 use wordcraft_doc::{Block, Blocks, Document, Paragraph, Path, StoryRef};
 use wordcraft_geom::{Point, Rect, Spin};
 
@@ -42,8 +46,10 @@ pub enum ViewMode {
     Print,
     /// One page as wide as the window, no page breaks.
     Web,
-    /// Draft/Outline: like web, page breaks shown as rules.
+    /// Draft: like web, page breaks shown as rules.
     Draft,
+    /// Outline: like draft, the body as an outline of its headings ([`outline`]).
+    Outline,
 }
 
 #[derive(Clone, Debug, Default)]
@@ -54,11 +60,44 @@ pub struct LayoutOptions {
     pub show_hidden: bool,
     /// Final text ("No Markup"): tracked deletions take no space and draw nothing.
     pub hide_deleted: bool,
-    /// Check spelling and grammar (squiggles).
+    /// Show revisions in balloons: tracked deletions in the body take no space and draw nothing
+    /// (the editor shows them in balloons beside the page). Headers, footers, notes and text
+    /// boxes get no balloons, so their deletions stay inline.
+    pub deletions_in_balloons: bool,
+    /// Check spelling as you type (squiggles).
     pub proofing: bool,
+    /// Print Markup (PDF, print, page images): widen each page by [`balloons::MARKUP_AREA`]
+    /// and show the comments there in balloons joined to their anchors, as Word prints them.
+    /// The editor draws its own interactive balloons and leaves this off.
+    pub comment_balloons: bool,
     /// Show field codes (`{ PAGE }`, shaded) instead of field results (View › Field Codes, Alt+F9).
     /// A field whose own `code` flag is set shows the other one.
     pub field_codes: bool,
+    /// Outline view: what's collapsed and shown (used when `view` is [`ViewMode::Outline`]).
+    pub outline: Option<outline::OutlineView>,
+    /// What the spelling check skips, and whether grammar is marked too (File › Options › Proofing).
+    pub proof: ProofOptions,
+}
+
+/// File › Options › Proofing choices that change the squiggles.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct ProofOptions {
+    /// Mark grammar errors as you type.
+    pub grammar: bool,
+    pub spelling: wordcraft_proof::Options,
+}
+
+impl Default for ProofOptions {
+    fn default() -> Self {
+        ProofOptions { grammar: true, spelling: wordcraft_proof::Options::default() }
+    }
+}
+
+impl LayoutOptions {
+    /// Whether tracked deletions in `story` take no space and draw nothing.
+    pub fn hides_deleted(&self, story: StoryRef) -> bool {
+        self.hide_deleted || (self.deletions_in_balloons && story == StoryRef::Body)
+    }
 }
 
 /// Something placed on a page (page coordinates, points, y down).
@@ -108,6 +147,8 @@ pub enum Placed {
         freeform: Option<Arc<wordcraft_doc::freeform::Freeform>>,
         effects: wordcraft_doc::effects::ShapeEffects,
         spin: Spin,
+        /// Arrowheads and text warp (see [`wordcraft_doc::connector::ShapeExtra`]).
+        extra: wordcraft_doc::connector::ShapeExtra,
     },
     /// A floating chart or diagram, drawn from its items inside `rect`. The object is the U+FFFC at
     /// byte `off` of paragraph `path` (its alt text).
@@ -127,9 +168,12 @@ pub enum Placed {
         spin: Spin,
         items: Vec<Placed>,
     },
-    /// A table cell's area (for hit testing and cell selection).
+    /// A table cell's area (for hit testing and cell selection). A vertically merged cell is
+    /// one `Cell` as tall as all its rows; its continuation rows get a `covered` `Cell` (their
+    /// own row's height) so the rows keep a box each, but it isn't a cell of its own on screen.
     Cell {
         rect: Rect,
+        covered: bool,
         table: Path,
         row: usize,
         cell: usize,
@@ -289,6 +333,9 @@ pub struct Page {
     pub footer_story: Option<u32>,
     /// Top-level body block index at the start of the page.
     pub first_block: usize,
+    /// Width of the markup area on the right of `w` that holds comment balloons (Print Markup,
+    /// [`LayoutOptions::comment_balloons`]); 0 without one. The document page is `w - markup` wide.
+    pub markup: f32,
 }
 
 /// The whole layout.
@@ -314,6 +361,7 @@ struct Key {
     excl: u64,
     eq: u32,
     grid: (u32, u32, u32, bool),
+    hide_deleted: bool,
 }
 
 /// Memoised paragraph layouts.
@@ -353,17 +401,28 @@ fn hash_of<T: Hash>(t: &T) -> u64 {
 
 fn env_hash(doc: &Document, opts: &LayoutOptions) -> u64 {
     let s = serde_json::to_string(&(&doc.styles, &doc.numbering, doc.settings.default_tab, &doc.settings.footnote_format)).unwrap_or_default();
+    // Outline view lays paragraphs out changed (no indents; plain without text formatting).
+    let outline = (opts.view == ViewMode::Outline).then(|| opts.outline.as_ref().is_some_and(|o| o.plain));
     hash_of(&(
         s,
         opts.show_hidden,
         opts.hide_deleted,
+        opts.deletions_in_balloons,
         opts.proofing,
         opts.field_codes,
-        wordcraft_proof::user_dictionary().len(),
-        doc.settings.auto_hyphenation,
+        opts.proof,
+        wordcraft_proof::dictionary_generation(),
+        hyphenation_key(doc),
+        outline,
     ))
 }
 
+/// The hyphenation settings, hashable (the zone as its bits).
+fn hyphenation_key(doc: &Document) -> (bool, u32, bool, u32) {
+    let s = &doc.settings;
+    (s.auto_hyphenation, s.hyphenation_zone.to_bits(), s.hyphenate_caps, s.consecutive_hyphen_limit)
+}
+
 fn has_page_fields(p: &Paragraph) -> bool {
     p.objects.iter().any(|o| match o {
         InlineObject::Field { instr, .. } => {
@@ -373,6 +432,55 @@ fn has_page_fields(p: &Paragraph) -> bool {
     })
 }
 
+/// Does `p` show a page total, which depends on how many pages the document has?
+fn has_total_fields(p: &Paragraph) -> bool {
+    p.objects.iter().any(|o| match o {
+        InlineObject::Field { instr, .. } => matches!(fields::field_name(instr).as_str(), "NUMPAGES" | "SECTIONPAGES"),
+        _ => false,
+    })
+}
+
+/// Page totals: of the document, and of each section (by index).
+#[derive(Clone, Debug, PartialEq)]
+struct Totals {
+    pages: u32,
+    sections: Vec<u32>,
+}
+
+impl Totals {
+    /// What a first pass assumes: one page.
+    fn first_guess(sections: usize) -> Totals {
+        Totals { pages: 1, sections: vec![1; sections] }
+    }
+    /// The totals of laid-out `pages` (a section without a page of its own counts one, as in
+    /// headers and footers).
+    fn of(pages: &[Page], sections: usize) -> Totals {
+        let mut per = vec![0u32; sections];
+        for p in pages {
+            if let Some(n) = per.get_mut(p.section) {
+                *n = n.saturating_add(1);
+            }
+        }
+        for n in &mut per {
+            *n = (*n).max(1);
+        }
+        Totals { pages: u32::try_from(pages.len()).unwrap_or(u32::MAX).max(1), sections: per }
+    }
+    fn section(&self, si: usize) -> u32 {
+        self.sections.get(si).copied().unwrap_or(1)
+    }
+}
+
+/// The most extra layout passes for page totals in the body: a total that changes the page
+/// count (its digits pushing text to another page) is tried again, this many times at most.
+const MAX_TOTAL_PASSES: usize = 3;
+
+/// A layout pass: finished, or to be done again with the page totals it found.
+enum Pass {
+    Done(DocLayout),
+    Again(Totals),
+}
+
 /// Walk state while paginating.
 struct Ctx<'a> {
     doc: &'a Document,
@@ -390,6 +498,14 @@ struct Ctx<'a> {
     chains: textbox::Chains,
     /// The current section's document grid (body text only: none for headers and footers).
     grid: para::Grid,
+    /// Whether tracked deletions are left out in the story being laid out
+    /// ([`LayoutOptions::hides_deleted`]): the body's, or the story of the [`layout_box`] at work.
+    hide_deleted: bool,
+    /// Whether body text (or its notes) laid out so far shows a page total (`NUMPAGES`,
+    /// `SECTIONPAGES`), which is only known once the whole body is paginated.
+    uses_totals: bool,
+    /// Whether to note `uses_totals` now (off while laying out headers and footers).
+    track_totals: bool,
 }
 
 impl Ctx<'_> {
@@ -432,7 +548,7 @@ impl Ctx<'_> {
             field_codes: false,
             hide_deleted: false,
             table: None,
-            proofing: false,
+            proofing: None,
             exclusions: &[],
             eq_number: 0,
             grid: para::Grid::default(),
@@ -460,6 +576,9 @@ impl Ctx<'_> {
         label: Option<(String, Level)>,
     ) -> Arc<ParaLayout> {
         let page = if has_page_fields(p) { Some(self.fields.page_key()) } else { None };
+        if self.track_totals && !self.uses_totals && has_total_fields(p) {
+            self.uses_totals = true;
+        }
         // Automatic equation numbers count through the document.
         let eq_here: u32 = p
             .objects
@@ -481,6 +600,7 @@ impl Ctx<'_> {
             excl: if exclusions.is_empty() { 0 } else { hash_of(&format!("{exclusions:?}")) },
             eq: if eq_here > 0 { eq_number } else { 0 },
             grid: self.grid.key(),
+            hide_deleted: self.hide_deleted,
         };
         self.cache.used.insert(key.clone());
         if let Some(pl) = self.cache.paras.get(&key) {
@@ -495,9 +615,9 @@ impl Ctx<'_> {
             fields: &self.fields,
             show_hidden: self.opts.show_hidden,
             field_codes: self.opts.field_codes,
-            hide_deleted: self.opts.hide_deleted,
+            hide_deleted: self.hide_deleted,
             table,
-            proofing: self.opts.proofing,
+            proofing: self.opts.proofing.then_some(self.opts.proof),
             exclusions,
             eq_number,
             grid: self.grid,
@@ -638,6 +758,9 @@ fn layout_box(
     depth: usize,
     frame: Option<PageFrame>,
 ) -> BoxLayout {
+    // Deletions in balloons leave the body's text only: a header, note or text box keeps its own
+    // inline (restored for the story around this box when it's done).
+    let outer_hide = std::mem::replace(&mut ctx.hide_deleted, ctx.opts.hides_deleted(story));
     let mut items = Vec::new();
     // Pictures behind the text go first; `behind` counts them.
     let mut behind = 0;
@@ -666,7 +789,7 @@ fn layout_box(
                 // Floating objects anchored here: place them, then wrap the text around them.
                 // One left out of the layout (hidden, or deleted in the final text) takes no room.
                 let mut floats = HashMap::new();
-                let left_out = left_out_objects(ctx.doc, p, table.map(|t| &t.chr), ctx.opts.show_hidden, ctx.opts.hide_deleted);
+                let left_out = left_out_objects(ctx.doc, p, table.map(|t| &t.chr), ctx.opts.show_hidden, ctx.hide_deleted);
                 for (oi, o) in p.objects.iter().enumerate() {
                     let Some((w, h, float)) = floating(o) else { continue };
                     if left_out(oi) {
@@ -732,6 +855,7 @@ fn layout_box(
         }
     }
     let floats_bottom = float_tables.iter().map(|r| r.bottom()).fold(0.0, f32::max);
+    ctx.hide_deleted = outer_hide;
     BoxLayout { items, height: y.max(0.0), floats_bottom }
 }
 
@@ -944,6 +1068,9 @@ struct PageBuilder<'a> {
     sect_beneath: bool,
     /// ... and so do the current page's (set as the page starts).
     beneath: bool,
+    /// Top of the footer of the pages being started: a footer reaching above the bottom margin
+    /// pushes the body up (`f32::MAX`: no footer).
+    foot_top: f32,
 }
 
 /// Gap above the footnote separator and its length.
@@ -1143,6 +1270,22 @@ impl NoteBox {
     }
 }
 
+/// Page borders, measured from the page edge (Word's default), so they surround the header,
+/// footer and line numbers. The first items of every printed page.
+fn page_border_rules(s: &SectionProps) -> Vec<Placed> {
+    let mut v = Vec::new();
+    if let Some(b) = &s.page_borders {
+        let sp = |e: &Option<Border>| e.map(|x| x.space).unwrap_or(24.0);
+        let (x0, x1, y0, y1) = (sp(&b.left), s.page_w - sp(&b.right), sp(&b.top), s.page_h - sp(&b.bottom));
+        for (e, a, bb) in [(b.top, (x0, y0), (x1, y0)), (b.bottom, (x0, y1), (x1, y1)), (b.left, (x0, y0), (x0, y1)), (b.right, (x1, y0), (x1, y1))] {
+            if let Some(e) = e.filter(Border::is_visible) {
+                v.push(Placed::Rule { x0: a.0, y0: a.1, x1: bb.0, y1: bb.1, border: e });
+            }
+        }
+    }
+    v
+}
+
 impl PageBuilder<'_> {
     /// Space footnotes take at the bottom of the page.
     fn notes_h(&self) -> f32 {
@@ -1270,22 +1413,13 @@ impl PageBuilder<'_> {
         let s = self.sect;
         self.number = self.number.saturating_add(1);
         let (w, h) = if self.web { (s.page_w, f32::MAX / 4.0) } else { (s.page_w, s.page_h) };
-        let body = Rect::new(s.margin_left + s.gutter, body_top, s.text_width(), (s.page_h - s.margin_bottom - body_top).max(36.0));
+        // A footer taller than the bottom margin pushes the body up (Word: no gap), leaving it at
+        // least a little room.
+        let bottom = (s.page_h - s.margin_bottom).min(self.foot_top.max(body_top + 36.0));
+        let body = Rect::new(s.margin_left + s.gutter, body_top, s.text_width(), (bottom - body_top).max(36.0));
         let mut decor = Vec::new();
         if !self.web {
-            // Page borders, measured from the page edge (Word's default), so they surround the
-            // header, footer and line numbers.
-            if let Some(b) = &s.page_borders {
-                let sp = |e: &Option<Border>| e.map(|x| x.space).unwrap_or(24.0);
-                let (x0, x1, y0, y1) = (sp(&b.left), s.page_w - sp(&b.right), sp(&b.top), s.page_h - sp(&b.bottom));
-                for (e, a, bb) in
-                    [(b.top, (x0, y0), (x1, y0)), (b.bottom, (x0, y1), (x1, y1)), (b.left, (x0, y0), (x0, y1)), (b.right, (x1, y0), (x1, y1))]
-                {
-                    if let Some(e) = e.filter(Border::is_visible) {
-                        decor.push(Placed::Rule { x0: a.0, y0: a.1, x1: bb.0, y1: bb.1, border: e });
-                    }
-                }
-            }
+            decor = page_border_rules(s);
             // Lines between columns.
             if s.columns.separator && s.columns.count > 1 {
                 let cols = s.column_boxes();
@@ -1294,7 +1428,7 @@ impl PageBuilder<'_> {
                         // Midway across the space between neighbours (leftwards in an RTL section).
                         let mid = if bx >= ax { (ax + aw + bx) / 2.0 } else { (bx + bw + ax) / 2.0 };
                         let x = s.margin_left + s.gutter + mid;
-                        decor.push(Placed::Rule { x0: x, y0: body_top, x1: x, y1: s.page_h - s.margin_bottom, border: Border::single(0.5) });
+                        decor.push(Placed::Rule { x0: x, y0: body_top, x1: x, y1: bottom, border: Border::single(0.5) });
                     }
                 }
             }
@@ -1305,7 +1439,7 @@ impl PageBuilder<'_> {
         self.col = 0;
         self.cols = s.column_boxes();
         self.top = body_top;
-        self.bottom = if self.web { f32::MAX / 8.0 } else { s.page_h - s.margin_bottom };
+        self.bottom = if self.web { f32::MAX / 8.0 } else { bottom };
         self.orig_bottom = self.bottom;
         self.y = self.top;
         // Notes continued from the page before come first in this page's note area.
@@ -1366,35 +1500,58 @@ const MAX_NOTE_PASSES: usize = 3;
 /// Lay out the whole document.
 pub fn layout(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions) -> DocLayout {
     let t0 = now_ms();
-    let mut pages = HashMap::new();
-    let mut l = layout_pass(doc, cache, opts, &pages);
+    // Page totals shown in the body (`NUMPAGES`, `SECTIONPAGES`) are known only after
+    // paginating: lay out again with the totals found until they hold (bounded). Footnotes
+    // numbered again on each page likewise settle over a few more passes.
     let per_page = opts.view == ViewMode::Print
         && doc.sections().iter().any(|(_, s)| doc.note_options(s, false).num_restart == wordcraft_doc::section::NoteRestart::EachPage);
-    if per_page {
-        // Number each page's footnotes from where the pass before placed them, until they stay.
-        for _ in 1..MAX_NOTE_PASSES {
-            let placed = footnote_pages(doc, &l.pages);
-            if placed == pages {
-                break;
+    let mut note_pages = HashMap::new();
+    let mut note_passes = 1;
+    let mut totals = Totals::first_guess(doc.sections().len());
+    let mut passes = 0;
+    let mut l = loop {
+        match layout_pass(doc, cache, opts, &note_pages, &totals, passes < MAX_TOTAL_PASSES) {
+            Pass::Again(t) => {
+                totals = t;
+                passes += 1;
+            }
+            Pass::Done(l) => {
+                if per_page && note_passes < MAX_NOTE_PASSES {
+                    // Number each page's footnotes from where the pass before placed them, until they stay.
+                    let placed = footnote_pages(doc, &l.pages);
+                    if placed != note_pages {
+                        note_pages = placed;
+                        note_passes += 1;
+                        continue;
+                    }
+                }
+                break l;
             }
-            pages = placed;
-            l = layout_pass(doc, cache, opts, &pages);
         }
-    }
+    };
     l.ms = now_ms() - t0;
     l
 }
 
-/// One layout pass, numbering footnotes restarted on each page by `note_pages` ([`note_info`]).
-fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, note_pages: &HashMap<u32, usize>) -> DocLayout {
-    let t0 = now_ms();
+/// One layout pass, numbering footnotes restarted on each page by `note_pages` ([`note_info`]),
+/// with `totals` assumed for the page totals in the body. With `may_repeat`, a pass whose body
+/// shows totals that turn out different asks to be done again.
+fn layout_pass(
+    doc: &Document,
+    cache: &mut LayoutCache,
+    opts: &LayoutOptions,
+    note_pages: &HashMap<u32, usize>,
+    totals: &Totals,
+    may_repeat: bool,
+) -> Pass {
     let env = env_hash(doc, opts);
     if env != cache.env {
         cache.paras.clear();
         cache.env = env;
     }
     cache.used.clear();
-    let notes = note_info(doc, opts.hide_deleted, note_pages);
+    // Note references are counted as the body shows them.
+    let notes = note_info(doc, opts.hides_deleted(StoryRef::Body), note_pages);
     let notes_hash = hash_of(&{
         let mut v: Vec<_> = notes.iter().map(|(a, b)| (*a, b.n, b.fmt)).collect();
         v.sort_by_key(|(a, ..)| *a);
@@ -1404,11 +1561,12 @@ fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, no
         doc,
         cache,
         opts,
+        hide_deleted: opts.hides_deleted(StoryRef::Body),
         counters: Counters::default(),
         fields: FieldCtx {
             page: 1,
-            pages: 1,
-            section_pages: 1,
+            pages: totals.pages,
+            section_pages: totals.section(0),
             section: 1,
             notes: Arc::new(notes),
             title: doc.core.title.as_str().into(),
@@ -1421,9 +1579,12 @@ fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, no
         boxes: wordcraft_doc::BoxBudget::default(),
         chains: Default::default(),
         grid: para::Grid::default(),
+        uses_totals: false,
+        track_totals: true,
     };
     let sections = doc.sections();
     let web = opts.view != ViewMode::Print;
+    let outline = (opts.view == ViewMode::Outline).then(|| OutlinePass::new(doc, opts.outline.clone().unwrap_or_default()));
     let default_sect = SectionProps::default();
     let mut web_sect;
     let first_sect = match sections.first() {
@@ -1469,6 +1630,7 @@ fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, no
         col_break_page: None,
         sect_beneath: false,
         beneath: false,
+        foot_top: f32::MAX,
     };
     // Endnotes in document order, with the section of their reference; placed at the end of a
     // section that keeps them there, else at the end of the document.
@@ -1486,8 +1648,24 @@ fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, no
     // Text boxes laid out in balancing attempts that were thrown away.
     let mut boxes_discarded = 0usize;
     let mut block = 0usize;
+    // Vertical sections are laid out on their pages turned on their side (see `vertical`).
+    let turned: Vec<Option<SectionProps>> = sections
+        .iter()
+        .map(|(_, s)| {
+            (!web && s.text_direction.is_turned()).then(|| {
+                let top = body_top_for(&mut ctx, s, s.headers.default);
+                vertical::unturned_sect(s, top)
+            })
+        })
+        .collect();
+    let mut prev_turn = TextDirection::Horizontal;
     for (si, (end, sect)) in sections.iter().enumerate() {
-        let sect: &SectionProps = if web { sect_ref } else { sect };
+        let turn = if web { TextDirection::Horizontal } else { sect.text_direction };
+        let sect: &SectionProps = match turned.get(si) {
+            Some(Some(t)) => t,
+            _ if web => sect_ref,
+            _ => sect,
+        };
         pb.sect = sect;
         pb.sect_idx = si;
         ctx.grid = para::Grid::default();
@@ -1496,8 +1674,14 @@ fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, no
         if !web && !doc.footnote_separators.is_empty() {
             pb.seps = NoteSeps::new(&mut ctx, &doc.footnote_separators, sect.text_width());
         }
-        let body_top = if web { sect.margin_top } else { body_top_for(&mut ctx, sect, sect.headers.default) };
-        let first_top = if web || !sect.title_page { body_top } else { body_top_for(&mut ctx, sect, sect.headers.first) };
+        ctx.fields.section = u32::try_from(si).unwrap_or(u32::MAX).saturating_add(1);
+        ctx.fields.section_pages = totals.section(si);
+        // Headers and footers left out are linked to the previous section's, and take its room.
+        let (heads, feet) = (linked(&sections, si, |s| s.headers), linked(&sections, si, |s| s.footers));
+        let body_top = if web || turn.is_turned() { sect.margin_top } else { body_top_for(&mut ctx, sect, heads.default) };
+        let first_top = if web || turn.is_turned() || !sect.title_page { body_top } else { body_top_for(&mut ctx, sect, heads.first) };
+        let foot_top = if web || turn.is_turned() { f32::MAX } else { foot_top_for(&mut ctx, sect, feet.default) };
+        let first_foot = if web || turn.is_turned() || !sect.title_page { foot_top } else { foot_top_for(&mut ctx, sect, feet.first) };
         ctx.grid = para::Grid::of(doc, sect);
         let restart = sect.page_num_start;
         if sect.line_numbers.as_ref().is_some_and(|l| l.restart == wordcraft_doc::section::LineNumberRestart::Section) {
@@ -1506,11 +1690,14 @@ fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, no
         let start = if si == 0 { SectionStart::NextPage } else { sect.start };
         if web && si > 0 {
             // one long page
-        } else if pb.pages.is_empty() || start != SectionStart::Continuous {
+        } else if pb.pages.is_empty() || start != SectionStart::Continuous || turn != prev_turn {
+            // A page holds text running one way: a section turning the other way starts a page.
             if let Some(n) = restart {
                 pb.number = n.saturating_sub(1);
             }
+            pb.foot_top = first_foot;
             pb.new_page(block, first_top);
+            pb.foot_top = foot_top;
             if !web && matches!(start, SectionStart::EvenPage | SectionStart::OddPage) {
                 let want_even = start == SectionStart::EvenPage;
                 if pb.number.is_multiple_of(2) != want_even {
@@ -1525,6 +1712,8 @@ fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, no
             pb.y = pb.top;
             pb.max_y = pb.top;
         }
+        prev_turn = turn;
+        pb.foot_top = foot_top;
         let last = (*end).min(doc.body.len().saturating_sub(1));
         // Newspaper columns are balanced on the section's last page when the next section starts
         // on the same page (a continuous break), as in Word. That page is laid out again from the
@@ -1538,9 +1727,11 @@ fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, no
         while block <= last {
             let Some(b) = doc.body.get(block) else { break };
             let before = balance.then(|| (pb.pages.len(), Snap::take(&mut pb, &ctx)));
-            match &**b {
-                Block::Para(p) => place_para(&mut ctx, &mut pb, p, block, body_top),
-                Block::Table(t) => place_table(&mut ctx, &mut pb, t, block, body_top),
+            match (&**b, &outline) {
+                (Block::Para(p), Some(o)) => place_outline_para(&mut ctx, &mut pb, p, block, o),
+                (Block::Table(_), Some(o)) if o.hidden.get(block).copied().unwrap_or(false) => {}
+                (Block::Para(p), None) => place_para(&mut ctx, &mut pb, p, block, body_top),
+                (Block::Table(t), _) => place_table(&mut ctx, &mut pb, t, block, body_top),
             }
             if let Some((pages, snap)) = before
                 && pb.pages.len() != pages
@@ -1583,6 +1774,13 @@ fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, no
     }
     pb.carry.clear();
     let mut pages = pb.pages;
+    for p in &mut pages {
+        if let Some((_, s)) = sections.get(p.section)
+            && !web
+        {
+            vertical::turn_page(p, s.text_direction, s);
+        }
+    }
     if web && let Some(p) = pages.first_mut() {
         let bottom = p
             .items
@@ -1592,8 +1790,18 @@ fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, no
         p.h = bottom + 36.0;
     }
     ctx.grid = para::Grid::default();
+    if !web && ctx.uses_totals && may_repeat {
+        let found = Totals::of(&pages, sections.len());
+        if found != *totals {
+            return Pass::Again(found);
+        }
+    }
     if !web {
+        ctx.track_totals = false;
         headers_footers(&mut ctx, &mut pages, &sections);
+        if doc.settings.mirror_margins {
+            mirror_even_pages(&mut pages, &sections);
+        }
     }
     // Evict paragraph layouts that weren't used this pass if the cache grew large.
     if ctx.cache.paras.len() > 4 * ctx.cache.used.len().max(1024) {
@@ -1609,7 +1817,12 @@ fn layout_pass(doc: &Document, cache: &mut LayoutCache, opts: &LayoutOptions, no
             }
         }
     }
-    DocLayout { pages, index, ms: now_ms() - t0, text_boxes: ctx.boxes.total().saturating_sub(boxes_discarded) }
+    let mut lay = DocLayout { pages, index, ms: 0.0, text_boxes: 0 };
+    if opts.comment_balloons && !web {
+        balloons::add(&mut ctx, &mut lay);
+    }
+    lay.text_boxes = ctx.boxes.total().saturating_sub(boxes_discarded);
+    Pass::Done(lay)
 }
 
 /// Pagination state saved before a block, to lay the blocks from there out again (balancing
@@ -1788,21 +2001,51 @@ fn place_endnotes(ctx: &mut Ctx, pb: &mut PageBuilder, ids: Vec<u32>, block: usi
         }
         pb.y += 8.0;
     }
+    let mut added = 0usize;
     for id in ids {
         let Some(part) = ctx.doc.parts.get(&id) else { continue };
         let blocks = part.blocks.clone();
         let BoxLayout { items, height: h, .. } = layout_box(ctx, StoryRef::Part(id), &blocks, &[], pb.col_w(), None, 0, None);
-        if pb.y + h > pb.bottom && !pb.at_top() {
-            pb.advance(block, pb.top);
-        }
-        let (x, y) = (pb.col_x(), pb.y);
-        if let Some(pg) = pb.page() {
-            for mut it in items {
-                it.translate(x, y);
-                pg.items.push(it);
+        // A note longer than the room left continues at a line break in the next column or on
+        // a new page (Word). Each page takes at least a line, so this ends; the page cap is a
+        // backstop (the rest then runs off the last page).
+        let mut note = NoteBox { id, items, h, cont: false };
+        loop {
+            let room = pb.bottom - pb.y;
+            let cut = if note.h <= room + 0.01 || added >= MAX_NOTE_PAGES {
+                None
+            } else {
+                let cuts = note.cuts();
+                match cuts.iter().rev().find(|&&c| c <= room + 0.01).or(cuts.first().filter(|_| pb.at_top())) {
+                    Some(&c) => Some(c),
+                    None if pb.at_top() => None,
+                    None => {
+                        pb.advance(block, pb.top);
+                        added += 1;
+                        continue;
+                    }
+                }
+            };
+            let (head, rest) = match cut {
+                Some(c) => {
+                    let (head, rest) = note.split(c);
+                    (head, Some(rest))
+                }
+                None => (note, None),
+            };
+            let (x, y) = (pb.col_x(), pb.y);
+            if let Some(pg) = pb.page() {
+                for mut it in head.items {
+                    it.translate(x, y);
+                    pg.items.push(it);
+                }
             }
+            pb.y += head.h;
+            let Some(rest) = rest else { break };
+            note = rest;
+            pb.advance(block, pb.top);
+            added += 1;
         }
-        pb.y += h;
     }
 }
 
@@ -1819,11 +2062,25 @@ fn body_top_for(ctx: &mut Ctx, sect: &SectionProps, header: Option<u32>) -> f32
     let blocks = part.blocks.clone();
     // Placed as `headers_footers` draws it, so page-relative floats wrap the same way.
     let frame = PageFrame { sect, origin: (sect.margin_left + sect.gutter, sect.header) };
+    let track = std::mem::replace(&mut ctx.track_totals, false);
     let h = layout_box(ctx, StoryRef::Part(id), &blocks, &[], sect.text_width(), None, 0, Some(frame)).height;
+    ctx.track_totals = track;
     // Word starts the body right below a header that reaches past the top margin, no gap.
     sect.margin_top.max(sect.header + h)
 }
 
+/// Where the footer starts (as `headers_footers` places it), `f32::MAX` without one.
+fn foot_top_for(ctx: &mut Ctx, sect: &SectionProps, footer: Option<u32>) -> f32 {
+    let Some(part) = footer.and_then(|id| ctx.doc.parts.get(&id).map(|p| (id, p))) else { return f32::MAX };
+    let (id, blocks) = (part.0, part.1.blocks.clone());
+    // A page total in the footer is filled in after pagination, like the header's: it doesn't
+    // make the body lay out again.
+    let track = std::mem::replace(&mut ctx.track_totals, false);
+    let h = layout_box(ctx, StoryRef::Part(id), &blocks, &[], sect.text_width(), None, 0, None).height;
+    ctx.track_totals = track;
+    sect.page_h - sect.footer - h
+}
+
 /// Where a box of laid-out items sits on its page, for floating objects positioned relative to
 /// the page or its margins.
 #[derive(Clone, Copy)]
@@ -1929,7 +2186,7 @@ fn float_items(o: &InlineObject, rect: Rect, outer: (Spin, Point), story: StoryR
         InlineObject::Image { media, crop, .. } => {
             vec![Placed::Image { rect, media: media.clone(), crop: *crop, story, path: Path(path.to_vec()), off, spin }]
         }
-        InlineObject::Shape { kind, fill, stroke, stroke_width, effects, freeform, .. } => {
+        InlineObject::Shape { kind, fill, stroke, stroke_width, effects, freeform, extra, .. } => {
             vec![Placed::Shape {
                 rect,
                 kind: *kind,
@@ -1939,6 +2196,7 @@ fn float_items(o: &InlineObject, rect: Rect, outer: (Spin, Point), story: StoryR
                 effects: *effects,
                 freeform: freeform.clone(),
                 spin,
+                extra: extra.clone(),
             }]
         }
         InlineObject::Graphic { graphic, .. } => {
@@ -1965,6 +2223,7 @@ fn float_items(o: &InlineObject, rect: Rect, outer: (Spin, Point), story: StoryR
                             effects: Default::default(),
                             freeform: None,
                             spin,
+                            extra: Default::default(),
                         },
                         Placed::Clip { rect, spin, items: members },
                     ]
@@ -2008,7 +2267,7 @@ fn anchor_floats(
         let frame = PageFrame { sect: pb.sect, origin: (0.0, 0.0) };
         // An object left out of the layout (hidden, or deleted in the final text) is not placed, so
         // it takes no room either.
-        let left_out = left_out_objects(ctx.doc, p, None, ctx.opts.show_hidden, ctx.opts.hide_deleted);
+        let left_out = left_out_objects(ctx.doc, p, None, ctx.opts.show_hidden, ctx.hide_deleted);
         for (oi, o) in p.objects.iter().enumerate() {
             let Some((w, h, float)) = floating(o) else { continue };
             if left_out(oi) {
@@ -2058,7 +2317,7 @@ fn place_objects(
     let (mut behind, mut front) = (Vec::new(), Vec::new());
     let Some(fl) = pl.lines.get(l0) else { return (behind, front) };
     // Objects left out of the layout (hidden, or deleted in the final text) aren't placed.
-    let left_out = left_out_objects(ctx.doc, p, at.table_chr, ctx.opts.show_hidden, ctx.opts.hide_deleted);
+    let left_out = left_out_objects(ctx.doc, p, at.table_chr, ctx.opts.show_hidden, ctx.hide_deleted);
     for li in l0..l1 {
         let Some(line) = pl.lines.get(li) else { continue };
         for k in line.c0..line.c1 {
@@ -2236,7 +2495,14 @@ fn place_para(ctx: &mut Ctx, pb: &mut PageBuilder, p: &Paragraph, block: usize,
             if bottom > limit + 0.01 && l1 > l0 && !split {
                 break;
             }
-            if bottom > limit + 0.01 && l1 == l0 && !pb.at_top() && !split {
+            // A line holding nothing but a page or column break stays at the bottom of the page
+            // even when it doesn't fit: it only ends the page, and moving it would leave a blank
+            // page behind it (Word does the same).
+            let only_break = matches!(l.end, LineEnd::PageBreak | LineEnd::ColumnBreak)
+                && p.text
+                    .get(l.start..l.stop)
+                    .is_some_and(|t| t.chars().all(|c| matches!(c, wordcraft_doc::para::PAGE_BREAK | wordcraft_doc::para::COLUMN_BREAK)));
+            if bottom > limit + 0.01 && l1 == l0 && !pb.at_top() && !split && !only_break {
                 break;
             }
             new_notes.extend(line_notes);
@@ -2287,7 +2553,9 @@ fn place_para(ctx: &mut Ctx, pb: &mut PageBuilder, p: &Paragraph, block: usize,
             // Relative, so a bottom moved down for notes continuing on the next page stays put.
             pb.bottom -= pb.notes_h() - before;
         }
-        let x = pb.col_x();
+        // Mirror indents: on an even (left-hand) page the inside indent is on the right, so the
+        // paragraph's lines (broken for the same width) move over by the indents' difference.
+        let x = pb.col_x() + mirror_shift(&pl.rp, pb.number, pb.web);
         let y = pb.y + lead;
         // Notes that no longer fit below the text (a long one, or the rest of one continued from
         // the page before) get what's left under it and continue on the next page.
@@ -2310,7 +2578,7 @@ fn place_para(ctx: &mut Ctx, pb: &mut PageBuilder, p: &Paragraph, block: usize,
         let (behind, front) = place_objects(ctx, StoryRef::Body, &[block as u32], p, &pl, (l0, l1), (x, y), &at, &float_rects, 0);
         items.extend(front);
         // Line numbers in the left margin.
-        if let Some(ln) = pb.sect.line_numbers.clone().filter(|_| !pb.web && pl.rp.style != "Header" && p.props.suppress_line_numbers != Some(true))
+        if let Some(ln) = pb.sect.line_numbers.clone().filter(|_| !pb.web && pl.rp.style != "Header" && !pl.rp.suppress_line_numbers)
             && let Some(first) = pl.lines.get(l0)
         {
             for li in l0..l1 {
@@ -2365,6 +2633,72 @@ fn place_para(ctx: &mut Ctx, pb: &mut PageBuilder, p: &Paragraph, block: usize,
     pb.prev = Some((pl.rp.style.clone(), pl.rp.contextual_spacing, pl.rp.space_after));
 }
 
+/// The outline of the body for an Outline view pass.
+struct OutlinePass {
+    view: outline::OutlineView,
+    levels: Vec<u8>,
+    hidden: Vec<bool>,
+}
+
+impl OutlinePass {
+    fn new(doc: &Document, view: outline::OutlineView) -> Self {
+        let levels = outline::levels(doc);
+        let hidden = outline::hidden(&levels, &view);
+        OutlinePass { view, levels, hidden }
+    }
+}
+
+/// A body paragraph in Outline view (one long sheet: no page or column breaks, no floats
+/// wrapping): indented by its level behind its symbol; hidden when collapsed or deeper than Show
+/// Level; body text cut to its first line with Show First Line Only.
+fn place_outline_para(ctx: &mut Ctx, pb: &mut PageBuilder, p: &Paragraph, block: usize, o: &OutlinePass) {
+    // List numbers count the hidden paragraphs too.
+    let label = ctx.next_label(p);
+    if o.hidden.get(block).copied().unwrap_or(false) {
+        return;
+    }
+    let level = o.levels.get(block).copied().unwrap_or(outline::BODY);
+    let indent = outline::indent(&o.levels, block);
+    let x = pb.col_x() + indent + outline::SYMBOL_W;
+    let width = (pb.col_w() - indent - outline::SYMBOL_W).max(72.0);
+    let q = outline::outline_para(ctx.doc, p, o.view.plain);
+    ctx.fields.page = pb.number;
+    let pl = ctx.para_labelled(&q, width, None, &[], label);
+    pb.y += pl.rp.space_before.max(0.0);
+    let n = pl.lines.len();
+    let l1 = if o.view.first_line_only && level >= outline::BODY { n.min(1) } else { n };
+    let y = pb.y + pl.lines.first().map(|f| f.top.max(0.0)).unwrap_or(0.0);
+    let mut items = Vec::new();
+    push_para(&mut items, StoryRef::Body, &[block as u32], &pl, 0, l1, x, y, width);
+    let at = ObjFrame { page: Some(PageFrame { sect: pb.sect, origin: (0.0, 0.0) }), col: (x, width), para_y: y, table_chr: None };
+    let (behind, front) = place_objects(ctx, StoryRef::Body, &[block as u32], &q, &pl, (0, l1), (x, y), &at, &HashMap::new(), 0);
+    items.extend(front);
+    let children = level < outline::BODY && outline::has_children(&o.levels, block);
+    // Collapsed, or with something under it hidden by Show Level: the wavy line says so.
+    let collapsed = children && o.hidden.get(block + 1).copied().unwrap_or(false);
+    items.extend(outline::symbol_items(&pl, x, y, level, children, collapsed));
+    if let Some(pg) = pb.page() {
+        for (i, it) in behind.into_iter().enumerate() {
+            pg.items.insert(i.min(pg.items.len()), it);
+        }
+        pg.items.extend(items);
+    }
+    if let (Some(f), Some(l)) = (pl.lines.first(), l1.checked_sub(1).and_then(|k| pl.lines.get(k))) {
+        pb.y = y + (l.top + l.height - f.top);
+    }
+    pb.y += pl.rp.space_after.max(0.0);
+}
+
+/// How far a paragraph with mirrored indents (`w:mirrorIndents`) moves right on page `number`:
+/// its left and right indents are the inside and outside ones, which swap sides on even pages.
+fn mirror_shift(rp: &wordcraft_doc::resolve::ResolvedPara, number: u32, web: bool) -> f32 {
+    if !rp.mirror_indents || web || !number.is_multiple_of(2) {
+        return 0.0;
+    }
+    let (left, right) = rp.visual_indents();
+    right - left
+}
+
 /// Height of the first line of the block after `block` (for keep-with-next).
 fn next_first_line(ctx: &mut Ctx, block: usize, width: f32) -> f32 {
     match ctx.doc.body.get(block + 1).map(|b| &**b) {
@@ -2378,9 +2712,9 @@ fn next_first_line(ctx: &mut Ctx, block: usize, width: f32) -> f32 {
                 fields: &ctx.fields,
                 show_hidden: ctx.opts.show_hidden,
                 field_codes: ctx.opts.field_codes,
-                hide_deleted: ctx.opts.hide_deleted,
+                hide_deleted: ctx.opts.hides_deleted(StoryRef::Body),
                 table: None,
-                proofing: false,
+                proofing: None,
                 exclusions: &[],
                 eq_number: ctx.eq_count,
                 grid: ctx.grid,
@@ -2441,6 +2775,7 @@ fn place_table(ctx: &mut Ctx, pb: &mut PageBuilder, t: &wordcraft_doc::Table, bl
             match split {
                 Some((a, b)) => {
                     place(pb, &a);
+                    table_notes(ctx, pb, &a.items);
                     rest = Some(b);
                 }
                 // Like Word, a row that does not fit on an empty page, or under the header rows
@@ -2459,10 +2794,39 @@ fn place_table(ctx: &mut Ctx, pb: &mut PageBuilder, t: &wordcraft_doc::Table, bl
             }
             fresh = true;
         }
-        place(pb, rest.as_ref().unwrap_or(row));
+        let last = rest.as_ref().unwrap_or(row);
+        place(pb, last);
+        table_notes(ctx, pb, &last.items);
     }
 }
 
+/// Footnotes referenced in the cell lines of a placed table row (or part of one) go to the
+/// bottom of the page, like those of body paragraphs; notes that don't fit there continue on
+/// the next page (see [`PageBuilder::flush_notes`]).
+fn table_notes(ctx: &mut Ctx, pb: &mut PageBuilder, items: &[Placed]) {
+    if pb.web {
+        return;
+    }
+    let mut ids: Vec<u32> = Vec::new();
+    for it in items {
+        let Placed::Lines { story: StoryRef::Body, para, l0, l1, .. } = it else { continue };
+        let (Some(a), Some(b)) = (para.lines.get(*l0), para.lines.get(l1.saturating_sub(1))) else { continue };
+        for (ci, id) in &para.notes {
+            if *ci >= a.c0 && *ci < b.c1 && !ids.contains(id) && !pb.notes.iter().any(|n| n.id == *id) {
+                ids.push(*id);
+            }
+        }
+    }
+    let before = pb.notes_h();
+    for id in ids {
+        let Some(part) = ctx.doc.parts.get(&id).filter(|p| p.kind == wordcraft_doc::PartKind::Footnote) else { continue };
+        let blocks = part.blocks.clone();
+        let BoxLayout { items, height: h, .. } = layout_box(ctx, StoryRef::Part(id), &blocks, &[], pb.sect.text_width(), None, 0, None);
+        pb.notes.push(NoteBox { id, items, h, cont: false });
+    }
+    pb.bottom -= pb.notes_h() - before;
+}
+
 /// Place floating table `tl` (`w:tblpPr`): at its own position, which takes no room in the text
 /// flow; the text after it wraps around it.
 fn place_floating_table(pb: &mut PageBuilder, tl: &table::TableLayout, f: &TableFloat, legacy: f32, block: usize, body_top: f32) {
@@ -2480,7 +2844,16 @@ fn place_floating_table(pb: &mut PageBuilder, tl: &table::TableLayout, f: &Table
         };
         let x = float_table_x(pb, w, f, legacy);
         let r = clear_of_float_tables(Rect::new(x, align_in(v_area, f.y, h, f.v_align), w, h), f, legacy, h_area.0, &pb.float_tables);
-        if attempt == 0 && r.bottom() > pb.bottom + 0.01 && !pb.at_top() && f.v_rel == Anchor::Paragraph {
+        // Like Word, a table that doesn't fit below the text before it moves to the next page with
+        // its anchor: one placed relative to the paragraph when it would run off the page, one
+        // placed on the page or margin when it would also cover the text already on the page.
+        let moves = if f.v_rel == Anchor::Paragraph {
+            r.bottom() > pb.bottom + 0.01
+        } else {
+            let covers_text = r.y < pb.y - 0.01 && r.bottom() > pb.top + 0.01 && r.x < pb.col_x() + pb.col_w() && r.right() > pb.col_x();
+            covers_text && pb.y + h > pb.bottom + 0.01
+        };
+        if attempt == 0 && moves && !pb.at_top() {
             pb.advance(block, body_top);
             continue;
         }
@@ -2536,6 +2909,22 @@ fn below(excl: &[WrapArea], mut y: f32, x0: f32, x1: f32) -> f32 {
     y
 }
 
+/// Section `si`'s headers (or footers, as `get` picks), with those it leaves out inherited from
+/// the sections before it (Word's "link to previous").
+fn linked(sections: &[(usize, &SectionProps)], si: usize, get: fn(&SectionProps) -> HeaderSet) -> HeaderSet {
+    let mut set = sections.get(si).map(|(_, s)| get(s)).unwrap_or_default();
+    for (_, s) in sections.iter().take(si).rev() {
+        if set.default.is_some() && set.first.is_some() && set.even.is_some() {
+            break;
+        }
+        let o = get(s);
+        set.default = set.default.or(o.default);
+        set.first = set.first.or(o.first);
+        set.even = set.even.or(o.even);
+    }
+    set
+}
+
 fn headers_footers(ctx: &mut Ctx, pages: &mut [Page], sections: &[(usize, &SectionProps)]) {
     let total = pages.len() as u32;
     // Pages per section.
@@ -2554,19 +2943,8 @@ fn headers_footers(ctx: &mut Ctx, pages: &mut [Page], sections: &[(usize, &Secti
     for (i, page) in pages.iter_mut().enumerate() {
         let Some((_, sect)) = sections.get(page.section) else { continue };
         // Inherit header/footer references from earlier sections (Word's "link to previous").
-        let pick = |get: &dyn Fn(&SectionProps) -> wordcraft_doc::section::HeaderSet| -> Option<u32> {
-            let mut set = get(sect);
-            for k in (0..page.section).rev() {
-                if set.default.is_some() && set.first.is_some() && set.even.is_some() {
-                    break;
-                }
-                if let Some((_, s)) = sections.get(k) {
-                    let o = get(s);
-                    set.default = set.default.or(o.default);
-                    set.first = set.first.or(o.first);
-                    set.even = set.even.or(o.even);
-                }
-            }
+        let pick = |get: fn(&SectionProps) -> HeaderSet| -> Option<u32> {
+            let set = linked(sections, page.section, get);
             if sect.title_page && first_of_section.contains(&i) {
                 return set.first;
             }
@@ -2575,8 +2953,8 @@ fn headers_footers(ctx: &mut Ctx, pages: &mut [Page], sections: &[(usize, &Secti
             }
             set.default
         };
-        let hid = pick(&|s: &SectionProps| s.headers);
-        let fid = pick(&|s: &SectionProps| s.footers);
+        let hid = pick(|s| s.headers);
+        let fid = pick(|s| s.footers);
         ctx.fields.page = page.number;
         ctx.fields.page_format = sect.page_num_format;
         ctx.fields.pages = total;
@@ -2613,6 +2991,24 @@ fn headers_footers(ctx: &mut Ctx, pages: &mut [Page], sections: &[(usize, &Secti
     }
 }
 
+/// Mirrored margins: even pages have the inside margin (and gutter) on the right, so their
+/// header, text, notes and footer move to start at the outside margin. Page borders, measured
+/// from the page edge, stay.
+fn mirror_even_pages(pages: &mut [Page], sections: &[(usize, &SectionProps)]) {
+    for page in pages.iter_mut().filter(|p| p.number % 2 == 0) {
+        let Some((_, s)) = sections.get(page.section) else { continue };
+        let dx = s.margin_right - s.margin_left - s.gutter;
+        if dx.abs() < 0.001 || !dx.is_finite() {
+            continue;
+        }
+        let borders = page_border_rules(s).len();
+        for it in page.items.iter_mut().skip(borders).chain(page.header.iter_mut()).chain(page.footer.iter_mut()) {
+            it.translate(dx, 0.0);
+        }
+        page.body.x += dx;
+    }
+}
+
 /// Is an object floating (not laid out inline)?
 pub fn is_floating(o: &InlineObject) -> bool {
     o.is_floating()
@@ -2638,6 +3034,12 @@ mod tests;
 #[cfg(test)]
 mod tests_bidi;
 #[cfg(test)]
+mod tests_complex;
+#[cfg(test)]
 mod tests_grid;
 #[cfg(test)]
+mod tests_pages;
+#[cfg(test)]
 mod tests_textbox;
+#[cfg(test)]
+mod tests_vertical;
diff --git a/crates/layout/src/outline.rs b/crates/layout/src/outline.rs
new file mode 100644
index 0000000000..af72e838dc
--- /dev/null
+++ b/crates/layout/src/outline.rs
@@ -0,0 +1,245 @@
+//! Outline view (View › Outline): the body as an outline of its headings. No pages: the text runs
+//! on one long sheet like Draft. Each paragraph is indented by its outline level and has a symbol
+//! in front of it: a circled plus for a heading with something under it, a circled minus for a
+//! heading with nothing under it, a small dot for body text. Collapsed headings hide what is under
+//! them and are marked with a wavy line; Show Level hides everything deeper than a level; Show
+//! First Line Only shows body paragraphs' first lines; without text formatting every paragraph is
+//! drawn in the Normal style. Paragraph indents and alignment aren't shown.
+//!
+//! What's collapsed is view state (not saved in the document): the caller passes it in
+//! [`OutlineView`] by body block index.
+
+use std::collections::BTreeSet;
+use std::sync::Arc;
+
+use wordcraft_doc::para::ShapeKind;
+use wordcraft_doc::props::{Align, Border, BorderStyle, CharProps, Rgb};
+use wordcraft_doc::{Block, Document, Paragraph, StoryRef};
+use wordcraft_geom::Rect;
+
+use crate::{DocLayout, Page, ParaLayout, Placed};
+
+/// The outline level of body text (headings are 1–9).
+pub const BODY: u8 = 10;
+/// How far each outline level is indented, points.
+pub const LEVEL_INDENT: f32 = 21.6;
+/// The gutter in front of each paragraph that holds its symbol, points.
+pub const SYMBOL_W: f32 = 16.0;
+
+const SYMBOL_GREY: Rgb = Rgb(0x6E, 0x6E, 0x6E);
+
+/// What the outline shows.
+#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
+pub struct OutlineView {
+    /// Collapsed headings (body block indices).
+    pub collapsed: BTreeSet<usize>,
+    /// Show Level: 1–9 shows headings down to that level (no body text); anything else shows all.
+    pub show_level: u8,
+    /// Show First Line Only: body paragraphs show their first line.
+    pub first_line_only: bool,
+    /// Show Text Formatting off: every paragraph is drawn in the Normal style.
+    pub plain: bool,
+}
+
+impl OutlineView {
+    /// The deepest level shown (body text is [`BODY`]).
+    pub fn deepest(&self) -> u8 {
+        if (1..=9).contains(&self.show_level) { self.show_level } else { BODY }
+    }
+}
+
+/// The outline level of a paragraph: 1–9 for headings (its style's or its own outline level),
+/// [`BODY`] for body text.
+pub fn para_level(doc: &Document, p: &Paragraph) -> u8 {
+    doc.styles.resolve_para(&p.props).outline_level.filter(|l| *l < 9).map(|l| l + 1).unwrap_or(BODY)
+}
+
+/// The outline level of every body block (tables are body text).
+pub fn levels(doc: &Document) -> Vec<u8> {
+    doc.body
+        .iter()
+        .map(|b| match &**b {
+            Block::Para(p) => para_level(doc, p),
+            Block::Table(_) => BODY,
+        })
+        .collect()
+}
+
+/// The end (exclusive) of what is under block `i`: the blocks after a heading up to the next
+/// heading of its level or higher. Body text has nothing under it (`i + 1`).
+pub fn subtree_end(levels: &[u8], i: usize) -> usize {
+    let Some(&l) = levels.get(i) else { return i };
+    if l >= BODY {
+        return i.saturating_add(1);
+    }
+    levels.iter().enumerate().skip(i.saturating_add(1)).find(|(_, x)| **x <= l).map(|(j, _)| j).unwrap_or(levels.len())
+}
+
+/// Whether heading `i` has anything under it.
+pub fn has_children(levels: &[u8], i: usize) -> bool {
+    subtree_end(levels, i) > i.saturating_add(1)
+}
+
+/// Which blocks the outline hides: deeper than Show Level, or under a collapsed heading.
+pub fn hidden(levels: &[u8], view: &OutlineView) -> Vec<bool> {
+    let deepest = view.deepest();
+    // While inside a collapsed heading: its level (blocks deeper than it are hidden).
+    let mut under: Option<u8> = None;
+    levels
+        .iter()
+        .enumerate()
+        .map(|(i, &l)| {
+            if let Some(h) = under {
+                if l > h {
+                    return true;
+                }
+                under = None;
+            }
+            if l > deepest {
+                return true;
+            }
+            if l < BODY && view.collapsed.contains(&i) {
+                under = Some(l);
+            }
+            false
+        })
+        .collect()
+}
+
+/// How far block `i` is indented: a heading by its level, body text one level deeper than the
+/// heading it follows.
+pub fn indent(levels: &[u8], i: usize) -> f32 {
+    let Some(&l) = levels.get(i) else { return 0.0 };
+    let depth = if l < BODY { l.saturating_sub(1) } else { levels.get(..i).unwrap_or(&[]).iter().rev().find(|x| **x < BODY).copied().unwrap_or(0) };
+    f32::from(depth) * LEVEL_INDENT
+}
+
+/// Character formatting kept without text formatting: what the text is (hidden, tracked, a
+/// link, its language and direction), not how it looks.
+fn plain_chars(c: &CharProps) -> CharProps {
+    CharProps {
+        hidden: c.hidden,
+        lang: c.lang.clone(),
+        no_proof: c.no_proof,
+        rtl: c.rtl,
+        cs: c.cs,
+        lang_bidi: c.lang_bidi.clone(),
+        link: c.link.clone(),
+        ins: c.ins,
+        del: c.del,
+        ..Default::default()
+    }
+}
+
+/// The paragraph as the outline draws it: no indents, start-aligned, and in the Normal style
+/// without text formatting (`plain`).
+pub(crate) fn outline_para(doc: &Document, p: &Paragraph, plain: bool) -> Paragraph {
+    let mut q = p.clone();
+    q.props.indent_left = Some(0.0);
+    q.props.indent_right = Some(0.0);
+    q.props.indent_first = Some(0.0);
+    q.props.align = Some(Align::Left);
+    q.props.page_break_before = Some(false);
+    q.props.drop_cap = None;
+    if plain {
+        let rp = doc.styles.resolve_para(&p.props);
+        q.props.style = None;
+        q.props.numbering = p.props.numbering.or(rp.numbering);
+        q.props.outline_level = None;
+        q.props.shading = None;
+        q.props.borders = None;
+        for r in &mut q.runs {
+            r.props = plain_chars(&r.props);
+        }
+        q.mark = plain_chars(&q.mark);
+    }
+    q
+}
+
+/// The symbol in front of a paragraph whose first line `pl` starts at (`x`, `y`) (the text's left
+/// edge): a circled plus or minus for a heading, a dot for body text; and a wavy line under a
+/// collapsed heading's first line.
+pub(crate) fn symbol_items(pl: &Arc<ParaLayout>, x: f32, y: f32, level: u8, children: bool, collapsed: bool) -> Vec<Placed> {
+    let Some(first) = pl.lines.first() else { return Vec::new() };
+    let asc = (first.baseline - first.top).max(4.0);
+    let cy = y + asc * 0.62;
+    let cx = x - SYMBOL_W + 6.0;
+    let mut out = Vec::new();
+    let disc = |r: f32| Placed::Shape {
+        rect: Rect::new(cx - r, cy - r, r * 2.0, r * 2.0),
+        kind: ShapeKind::Ellipse,
+        fill: Some(SYMBOL_GREY),
+        stroke: None,
+        stroke_width: 0.0,
+        freeform: None,
+        effects: Default::default(),
+        spin: Default::default(),
+        extra: Default::default(),
+    };
+    let white = Border { style: BorderStyle::Single, width: 1.1, color: Some(Rgb(0xFF, 0xFF, 0xFF)), space: 0.0 };
+    if level >= BODY {
+        out.push(disc(2.0));
+        return out;
+    }
+    let r = 4.6;
+    out.push(disc(r));
+    out.push(Placed::Rule { x0: cx - 2.6, y0: cy, x1: cx + 2.6, y1: cy, border: white });
+    if children {
+        out.push(Placed::Rule { x0: cx, y0: cy - 2.6, x1: cx, y1: cy + 2.6, border: white });
+    }
+    if collapsed {
+        let w = first.xs.last().copied().unwrap_or(0.0).max(12.0);
+        let by = y + (first.baseline - first.top) + 3.0;
+        out.push(Placed::Rule {
+            x0: x,
+            y0: by,
+            x1: x + w,
+            y1: by,
+            border: Border { style: BorderStyle::Wave, width: 0.75, color: Some(SYMBOL_GREY), space: 0.0 },
+        });
+    }
+    out
+}
+
+impl DocLayout {
+    /// The outline symbol at page point (`x`, `y`), as the body block it belongs to (Outline view:
+    /// clicking a symbol selects the heading and what is under it).
+    pub fn outline_symbol_at(&self, page: usize, x: f32, y: f32) -> Option<usize> {
+        let page: &Page = self.pages.get(page)?;
+        page.items.iter().find_map(|it| {
+            let Placed::Lines { story: StoryRef::Body, path, para, l0: 0, x: lx, y: ly, .. } = it else { return None };
+            let [block] = path.0.as_slice() else { return None };
+            let first = para.lines.first()?;
+            let r = Rect::new(lx - SYMBOL_W, *ly, SYMBOL_W, first.height.max(8.0));
+            (x >= r.x && x <= r.x + r.w && y >= r.y && y <= r.y + r.h).then_some(*block as usize)
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn show_level_and_collapse_hide_what_is_under_a_heading() {
+        // H1, body, H2, body, H1, body
+        let levels = [1, BODY, 2, BODY, 1, BODY];
+        let all = OutlineView::default();
+        assert_eq!(hidden(&levels, &all), vec![false; 6]);
+        let one = OutlineView { show_level: 1, ..Default::default() };
+        assert_eq!(hidden(&levels, &one), vec![false, true, true, true, false, true]);
+        let two = OutlineView { show_level: 2, ..Default::default() };
+        assert_eq!(hidden(&levels, &two), vec![false, true, false, true, false, true]);
+        // Collapsing the first heading hides its whole subtree, not the next Heading 1.
+        let c = OutlineView { collapsed: [0].into_iter().collect(), ..Default::default() };
+        assert_eq!(hidden(&levels, &c), vec![false, true, true, true, false, false]);
+        // Collapsing body text does nothing.
+        let b = OutlineView { collapsed: [1].into_iter().collect(), ..Default::default() };
+        assert_eq!(hidden(&levels, &b), vec![false; 6]);
+        assert!(has_children(&levels, 0) && has_children(&levels, 2) && !has_children(&levels, 1));
+        assert_eq!(subtree_end(&levels, 0), 4);
+        assert_eq!(subtree_end(&levels, 99), 99);
+        assert_eq!(indent(&levels, 3), 2.0 * LEVEL_INDENT);
+        assert_eq!(indent(&levels, 0), 0.0);
+    }
+}
diff --git a/crates/layout/src/para.rs b/crates/layout/src/para.rs
index 22dff9eb50..4ab1dafe00 100644
--- a/crates/layout/src/para.rs
+++ b/crates/layout/src/para.rs
@@ -215,8 +215,13 @@ impl Line {
 #[derive(Clone, Debug)]
 pub struct Label {
     pub text: String,
+    /// Style of the label's last run (the suffix space and the bidi tests measure with it).
     pub style: u16,
     pub glyphs: Vec<Glyph>,
+    /// Font runs over `glyphs`, in drawing order: font fallback can split a label ("1、" takes
+    /// the digit from the Latin face and the comma from a CJK one), and each glyph id only means
+    /// something in the face it was shaped with.
+    pub runs: Vec<LabelRun>,
     pub x: f32,
     pub width: f32,
 }
@@ -236,6 +241,17 @@ pub struct RubyLayout {
     pub raise: f32,
 }
 
+/// One font run of a list label.
+#[derive(Clone, Debug)]
+pub struct LabelRun {
+    /// Index into `ParaLayout::styles`.
+    pub style: u16,
+    /// Glyph range in `Label::glyphs`.
+    pub glyphs: std::ops::Range<usize>,
+    /// The run's characters (for the PDF text layer).
+    pub text: String,
+}
+
 /// A laid-out paragraph.
 #[derive(Clone, Debug)]
 pub struct ParaLayout {
@@ -316,7 +332,8 @@ pub struct ParaEnv<'a> {
     pub hide_deleted: bool,
     /// The table style's formatting for text in this paragraph's cell (`None` outside tables).
     pub table: Option<&'a CellText>,
-    pub proofing: bool,
+    /// Check spelling (and grammar, as the options say) for squiggles; `None` = no squiggles.
+    pub proofing: Option<crate::ProofOptions>,
     /// Areas text must flow around (floating objects), relative to the paragraph: x from the
     /// column's left edge, y from the top of the first line.
     pub exclusions: &'a [Exclusion],
@@ -493,6 +510,12 @@ pub fn visual_order(levels: &[u8]) -> Vec<usize> {
     order
 }
 
+/// Text Word sets in the East Asian font: CJK ideographs, kana, bopomofo, CJK punctuation and
+/// fullwidth forms, and Hangul.
+fn east_asian(c: char) -> bool {
+    crate::kinsoku::is_east_asian(c) || matches!(u32::from(c), 0x1100..=0x11FF | 0x3130..=0x318F | 0xAC00..=0xD7AF)
+}
+
 impl<'a> Builder<'a> {
     /// Style index for a resolved char in `face` (caps-scaled `size` override for small caps).
     fn style(&mut self, rc: &Arc<ResolvedChar>, face_override: Option<FaceRef>, small: bool) -> u16 {
@@ -562,6 +585,15 @@ impl<'a> Builder<'a> {
         let rc_cs: Option<Arc<ResolvedChar>> = text.chars().any(|c| rc.uses_complex(c)).then(|| Arc::new(rc.complex()));
         let primary = wordcraft_fonts::word::resolve(&rc.font, rc.bold, rc.italic).face;
         let primary_cs = rc_cs.as_ref().map(|r| wordcraft_fonts::word::resolve(&r.font, r.bold, r.italic).face);
+        // Chinese, Japanese and Korean characters use the run's East Asian font (`w:eastAsia`) when
+        // it is installed and has them.
+        let primary_ea = rc
+            .font_ea
+            .as_ref()
+            .filter(|f| !f.eq_ignore_ascii_case(&rc.font) && text.chars().any(east_asian))
+            .map(|f| wordcraft_fonts::word::resolve(f, rc.bold, rc.italic))
+            .filter(|r| !r.substituted)
+            .map(|r| r.face);
         let use_levels = para_text && !self.levels.is_empty();
         // Split by font coverage (fallback faces), small caps case, script formatting and direction.
         let mut seg_start = 0;
@@ -576,6 +608,7 @@ impl<'a> Builder<'a> {
             let prim = if complex { primary_cs.unwrap_or(primary) } else { primary };
             let face = match cur {
                 Some(k) if mark => k.face,
+                _ if !complex && east_asian(c) && primary_ea.is_some_and(|f| f.covers(c)) => primary_ea,
                 _ if prim.covers(c) || c.is_whitespace() || c.is_control() || c == SOFT_HYPHEN => None,
                 // Stay in the fallback face the word started in while it covers the letters.
                 Some(SegKey { face: Some(f), .. }) if f.covers(c) => Some(f),
@@ -620,7 +653,9 @@ impl<'a> Builder<'a> {
             let k = st.size / st.face.upem.max(1.0) as f32;
             let hscale = rc.scale / 100.0;
             // Group glyphs by cluster byte offset; graphemes may span several shaper clusters.
-            let bounds: Vec<usize> = unicode_segmentation::UnicodeSegmentation::grapheme_indices(sub, true).map(|(i, _)| i).collect();
+            // Complex-script syllables the graphemes split (Myanmar vowel signs, stacked
+            // consonants) stay one cluster: the caret never stops inside them.
+            let bounds: Vec<usize> = wordcraft_doc::cluster::cluster_starts(sub);
             let mut gi = 0usize;
             for (bi, &gs) in bounds.iter().enumerate() {
                 let ge = bounds.get(bi + 1).copied().unwrap_or(sub.len());
@@ -919,17 +954,21 @@ pub(crate) fn left_out(rc: &ResolvedChar, show_hidden: bool, hide_deleted: bool)
 pub fn layout_para(p: &Paragraph, env: &ParaEnv) -> ParaLayout {
     let doc = env.doc;
     let mut rp = doc.styles.resolve_para_in(&p.props, env.table.map(|t| &t.para));
+    let para_style = p.props.style.as_deref();
+    let table_chr = env.table.map(|t| &t.chr);
+    // Indents in characters are measured in the paragraph mark's font size.
+    if rp.indent_chars.iter().any(|c| *c != 0.0) {
+        rp.set_char_unit(doc.styles.resolve_char_in(para_style, table_chr, &p.mark).size);
+    }
     // List level indents apply unless the paragraph sets its own.
     if let Some((_, lvl)) = &env.label {
-        if p.props.indent_left.is_none() {
+        if p.props.indent_left.is_none() && p.props.indent_left_chars.is_none_or(|c| c == 0.0) {
             rp.indent_left = lvl.indent;
         }
-        if p.props.indent_first.is_none() {
+        if p.props.indent_first.is_none() && p.props.indent_first_chars.is_none_or(|c| c == 0.0) {
             rp.indent_first = -lvl.hanging;
         }
     }
-    let para_style = p.props.style.as_deref();
-    let table_chr = env.table.map(|t| &t.chr);
     let resolve = |c: &CharProps| -> Arc<ResolvedChar> { Arc::new(doc.styles.resolve_char_in(para_style, table_chr, c)) };
     let levels = bidi_levels(&p.text, rp.bidi);
     let mut b =
@@ -1186,6 +1225,12 @@ pub fn layout_para(p: &Paragraph, env: &ParaEnv) -> ParaLayout {
             found.push(i);
         }
     }
+    // Myanmar has no spaces between words: it wraps between syllables.
+    if text.chars().any(|c| matches!(u32::from(c), 0x1000..=0x109F | 0xA9E0..=0xA9FF | 0xAA60..=0xAA7F)) {
+        found.extend(wordcraft_doc::cluster::myanmar_breaks(&text));
+        found.sort_unstable();
+        found.dedup();
+    }
     // Asian typography: kinsoku and breaking Latin words anywhere.
     crate::kinsoku::apply(&text, &mut found, rp.kinsoku, rp.word_wrap);
     let opps: std::collections::HashSet<usize> = found.into_iter().filter_map(to_para).collect();
@@ -1220,17 +1265,27 @@ pub fn layout_para(p: &Paragraph, env: &ParaEnv) -> ParaLayout {
             cl = order.iter().filter_map(|&i| cl.get(i).cloned()).collect();
         }
         let mut glyphs = Vec::new();
+        let mut runs: Vec<LabelRun> = Vec::new();
         let mut x = 0.0;
         let mut style = mark_style;
         for c in &cl {
             style = c.style;
+            let g0 = glyphs.len();
             for g in b.glyphs.get(c.g0 as usize..c.g1 as usize).into_iter().flatten() {
                 glyphs.push(Glyph { dx: g.dx + x, ..*g });
             }
+            let chars = text.get(c.start..c.end).unwrap_or("");
+            match runs.last_mut() {
+                Some(r) if r.style == c.style => {
+                    r.glyphs.end = glyphs.len();
+                    r.text.push_str(chars);
+                }
+                _ => runs.push(LabelRun { style: c.style, glyphs: g0..glyphs.len(), text: chars.to_string() }),
+            }
             x += c.adv;
         }
         b.glyphs.truncate(before_g);
-        Label { text, style, glyphs, x: 0.0, width: x }
+        Label { text, style, glyphs, runs, x: 0.0, width: x }
     });
 
     let mut pl = ParaLayout {
@@ -1245,7 +1300,7 @@ pub fn layout_para(p: &Paragraph, env: &ParaEnv) -> ParaLayout {
         text_len: p.text.len(),
         has_page_fields,
         notes,
-        issues: if env.proofing { proof_issues(p, &runs) } else { Vec::new() },
+        issues: env.proofing.map(|o| proof_issues(p, &runs, &o)).unwrap_or_default(),
         drop_cap,
         hyph_after: Vec::new(),
         bidi_levels: b.levels,
@@ -1256,7 +1311,8 @@ pub fn layout_para(p: &Paragraph, env: &ParaEnv) -> ParaLayout {
         left_out: Vec::new(),
         enclosures,
     };
-    pl.hyph_after = hyphenation_points(&text, to_para, &pl, env.doc.settings.auto_hyphenation && !pl.rp.suppress_hyphens, &runs);
+    let auto = env.doc.settings.auto_hyphenation && !pl.rp.suppress_hyphens;
+    pl.hyph_after = hyphenation_points(&text, to_para, &pl, auto, env.doc.settings.hyphenate_caps, &runs);
     pl.left_out = left;
     for k in pl.hyph_after.clone() {
         if let Some(c) = pl.clusters.get_mut(k as usize) {
@@ -1295,6 +1351,9 @@ fn break_lines(pl: &mut ParaLayout, env: &ParaEnv, mark_style: u16, level: Optio
     // spaces, up to MAX_SPACE_SHRINK of their width; never on lines with tabs.
     let shrink_spaces = rp.align == Align::Justify && env.doc.settings.compat_mode >= wordcraft_doc::COMPAT_MODE_CURRENT;
     let hanging_at = if rp.indent_first < 0.0 { Some(rp.indent_left) } else { None };
+    // Hyphenation Options: the zone, and how many lines in a row may end with a hyphen.
+    let zone = Some(env.doc.settings.hyphenation_zone).filter(|z| z.is_finite() && *z >= 0.0).unwrap_or(HYPHENATION_ZONE).min(1584.0);
+    let hyph_limit = env.doc.settings.consecutive_hyphen_limit as usize;
     let n = pl.clusters.len();
     // A right-to-left paragraph is laid out from its start edge, as if mirrored: indents, tabs,
     // the list label and alignment are measured from the right. Lines are mirrored back (and
@@ -1401,6 +1460,8 @@ fn break_lines(pl: &mut ParaLayout, env: &ParaEnv, mark_style: u16, level: Optio
         let mut leaders = Vec::new();
         let mut last_break: Option<usize> = None; // cluster index after which we may break
         let mut last_plain: Option<(usize, f32)> = None; // last non-hyphen break and the x after it
+        // After `hyph_limit` hyphenated lines in a row this one may not end with a hyphen.
+        let hyph_ok = hyph_limit == 0 || lines.iter().rev().take_while(|l| l.hyphen.is_some()).count() < hyph_limit;
         let mut end = LineEnd::Para;
         let mut j = i;
         let mut pending_tab: Option<(usize, TabStop, f32)> = None; // tab cluster, stop, x where tab started
@@ -1484,7 +1545,7 @@ fn break_lines(pl: &mut ParaLayout, env: &ParaEnv, mark_style: u16, level: Optio
                     && pj >= c0
                     && pj < bk
                     && pl.hyph_after.binary_search(&(bk as u32)).is_ok()
-                    && right_edge - px <= HYPHENATION_ZONE
+                    && right_edge - px <= zone
                 {
                     last_break = Some(pj);
                 }
@@ -1558,7 +1619,7 @@ fn break_lines(pl: &mut ParaLayout, env: &ParaEnv, mark_style: u16, level: Optio
                 if !hyph {
                     last_break = Some(j);
                     last_plain = Some((j, x));
-                } else if x + hyphen_glyph(pl, c.style, &mut hcache).2 <= right_edge + shrink + 0.01 {
+                } else if hyph_ok && x + hyphen_glyph(pl, c.style, &mut hcache).2 <= right_edge + shrink + 0.01 {
                     last_break = Some(j);
                 }
             }
@@ -1628,12 +1689,11 @@ fn break_lines(pl: &mut ParaLayout, env: &ParaEnv, mark_style: u16, level: Optio
             asc = st.ascent;
             desc = st.descent;
         }
-        if first
-            && let Some(lab) = &pl.label
-            && let Some(st) = pl.styles.get(lab.style as usize)
-        {
-            asc = asc.max(st.ascent);
-            desc = desc.max(st.descent);
+        if first && let Some(lab) = &pl.label {
+            for st in lab.runs.iter().filter_map(|r| pl.styles.get(r.style as usize)) {
+                asc = asc.max(st.ascent);
+                desc = desc.max(st.descent);
+            }
         }
         // Line spacing scales the text's height, never a picture's: a line is at least as tall
         // as its tallest picture plus the descent below the baseline.
@@ -1654,7 +1714,7 @@ fn break_lines(pl: &mut ParaLayout, env: &ParaEnv, mark_style: u16, level: Optio
             let up = asc.max(obj_asc);
             top + ((height - up - desc) / 2.0).max(0.0) + up
         } else {
-            top + height - desc
+            top + baseline_offset(rp.line_spacing, asc, height, desc).max(obj_asc.min(height - desc))
         };
 
         // Alignment / justification (trailing spaces hang).
@@ -1783,7 +1843,7 @@ fn break_lines(pl: &mut ParaLayout, env: &ParaEnv, mark_style: u16, level: Optio
                 lines.push(Line {
                     top,
                     height: h,
-                    baseline: top + h - desc,
+                    baseline: top + if grid.is_some() { h - desc } else { baseline_offset(rp.line_spacing, asc, h, desc) },
                     c0: n,
                     c1: n,
                     xs: vec![x0],
@@ -1901,6 +1961,18 @@ fn reorder_line(pl: &ParaLayout, line: &mut Line, width: f32) {
 /// paragraph beside a floating table in a 21.3pt gap but not in an 18.6pt one.
 const MIN_SPAN: f32 = 20.0;
 
+/// How far below a line's top its baseline sits. Multiple spacing at or above single keeps the
+/// text at the top of the line and puts the extra leading below the baseline; below single it
+/// shrinks the whole box, ascent included (Word's output for docxide-pdf's fixtures: 1.15-spaced
+/// Times New Roman 12pt sits one ascent below the line top, not 1.8pt lower). Exact and at-least
+/// spacing keep the descent below the baseline and the rest above it.
+fn baseline_offset(spacing: LineSpacing, asc: f32, height: f32, desc: f32) -> f32 {
+    match spacing {
+        LineSpacing::Multiple(m) => asc * m.min(1.0),
+        LineSpacing::AtLeast(_) | LineSpacing::Exactly(_) => height - desc,
+    }
+}
+
 /// The spans of a row at `top` (about `h` tall) between `lo` and `hi` that text can use around
 /// the exclusions, left to right (Square wrapping uses both sides of an object). `Err(y)`: none
 /// here, try again at `y` (below what's in the way).
@@ -1951,7 +2023,7 @@ fn row_spans(exclusions: &[Exclusion], top: f32, h: f32, lo: f32, hi: f32) -> Re
 }
 
 /// Word's default hyphenation zone (0.25"), points.
-const HYPHENATION_ZONE: f32 = 18.0;
+const HYPHENATION_ZONE: f32 = wordcraft_doc::DEFAULT_HYPHENATION_ZONE;
 
 /// How much of their width the spaces of a justified line may give up to fit more text (Word
 /// 2013+, compatibility mode 15).
@@ -2006,10 +2078,10 @@ fn hyphen_glyph(pl: &ParaLayout, style: u16, cache: &mut Vec<(u16, u32, f32)>) -
 
 /// Clusters after which a line may end with a hyphen: soft hyphens always, and dictionary or
 /// pattern hyphenation points of each word, in the language of its run ([`ProofRun`]), when
-/// automatic hyphenation is on. Both are found in `text`, the paragraph as laid out (without what
+/// automatic hyphenation is on (words in capitals only with `caps`). Both are found in `text`, the paragraph as laid out (without what
 /// the layout leaves out, [`left_out`]), and `to_para` maps the end of a char there to the
 /// paragraph's text.
-fn hyphenation_points(text: &str, to_para: impl Fn(usize) -> Option<usize>, pl: &ParaLayout, auto: bool, runs: &[ProofRun]) -> Vec<u32> {
+fn hyphenation_points(text: &str, to_para: impl Fn(usize) -> Option<usize>, pl: &ParaLayout, auto: bool, caps: bool, runs: &[ProofRun]) -> Vec<u32> {
     let mut bytes: Vec<usize> = text.char_indices().filter(|(_, c)| *c == SOFT_HYPHEN).map(|(i, c)| i + c.len_utf8()).collect();
     if auto {
         let lim = wordcraft_proof::hyphen::Limits::default();
@@ -2020,9 +2092,12 @@ fn hyphenation_points(text: &str, to_para: impl Fn(usize) -> Option<usize>, pl:
                 (None, true) => start = Some(i),
                 (Some(a), false) => {
                     // The patterns are for Latin-script languages: never hyphenate Persian/Arabic words.
+                    // Words in capitals (`NASA`, `README`) only when the document allows it.
+                    let all_caps = |w: &str| w.chars().filter(|c| c.is_alphabetic()).all(char::is_uppercase);
                     if let Some(w) = text.get(a..i)
                         && w.chars().count() >= lim.min_word
                         && !w.chars().any(wordcraft_fonts::is_rtl)
+                        && (caps || !all_caps(w))
                     {
                         // The word's language: its first letter's run, found by its place in `p.text`.
                         let first = w.chars().next().map_or(1, char::len_utf8);
@@ -2236,20 +2311,24 @@ fn lang_at(runs: &[ProofRun], off: usize) -> wordcraft_proof::ProofLang {
 }
 
 /// Spelling and grammar issues in a paragraph, in order: each word in its run's language
-/// ([`wordcraft_proof::check_text`]), and none touching a run left unchecked.
-pub fn paragraph_issues(p: &Paragraph, runs: &[ProofRun]) -> Vec<wordcraft_proof::Issue> {
+/// ([`wordcraft_proof::check_text_with`]: what spelling skips, and grammar only with `grammar`),
+/// and none touching a run left unchecked.
+pub fn paragraph_issues(p: &Paragraph, runs: &[ProofRun], spelling: &wordcraft_proof::Options, grammar: bool) -> Vec<wordcraft_proof::Issue> {
     if p.text.trim().is_empty() || p.text.len() > 100_000 {
         return Vec::new();
     }
     let text = proof_text(p);
     let spans: Vec<(std::ops::Range<usize>, wordcraft_proof::ProofLang)> = runs.iter().map(|r| (r.range.clone(), r.lang)).collect();
     let skip = |a: usize, b: usize| runs.iter().any(|r| r.skip && r.range.start < b && a < r.range.end);
-    wordcraft_proof::check_text(&text, &spans).into_iter().filter(|i| !skip(i.start, i.end)).collect()
+    wordcraft_proof::check_text_with(&text, &spans, spelling, grammar).into_iter().filter(|i| !skip(i.start, i.end)).collect()
 }
 
 /// Spelling and grammar issues in a paragraph as squiggles: (start, end, is grammar).
-fn proof_issues(p: &Paragraph, runs: &[ProofRun]) -> Vec<(usize, usize, bool)> {
-    paragraph_issues(p, runs).into_iter().map(|i| (i.start, i.end, i.kind == wordcraft_proof::IssueKind::Grammar)).collect()
+fn proof_issues(p: &Paragraph, runs: &[ProofRun], opts: &crate::ProofOptions) -> Vec<(usize, usize, bool)> {
+    paragraph_issues(p, runs, &opts.spelling, opts.grammar)
+        .into_iter()
+        .map(|i| (i.start, i.end, i.kind == wordcraft_proof::IssueKind::Grammar))
+        .collect()
 }
 
 /// Text for proofing with the same byte offsets: inline objects and tracked deletions become
diff --git a/crates/layout/src/table.rs b/crates/layout/src/table.rs
index c9f4851f77..c305674be8 100644
--- a/crates/layout/src/table.rs
+++ b/crates/layout/src/table.rs
@@ -167,7 +167,7 @@ pub fn measure_table_columns(doc: &wordcraft_doc::Document, t: &Table) -> Vec<(f
                 field_codes: false,
                 hide_deleted: false,
                 table: text.as_ref(),
-                proofing: false,
+                proofing: None,
                 exclusions: &[],
                 eq_number: 0,
                 grid: crate::para::Grid::default(),
@@ -662,7 +662,14 @@ pub fn layout_table(ctx: &mut Ctx, story: StoryRef, t: &Table, path: &[u32], ava
             if let Some(e) = b.right.filter(Border::is_visible) {
                 items.push(Placed::Rule { x0: x1, y0, x1, y1, border: e });
             }
-            items.push(Placed::Cell { rect: Rect::new(c.x, 0.0, c.w, rh), table: wordcraft_doc::Path(path.to_vec()), row: ri, cell: ci, story });
+            items.push(Placed::Cell {
+                rect: Rect::new(c.x, 0.0, c.w, if c.vmerge == VMerge::Continue { rh } else { span_h }),
+                covered: c.vmerge == VMerge::Continue,
+                table: wordcraft_doc::Path(path.to_vec()),
+                row: ri,
+                cell: ci,
+                story,
+            });
         }
         out.push(RowLayout { height: rh, items });
     }
@@ -790,9 +797,9 @@ pub fn split_row(row: &RowLayout, cut: f32) -> Option<(RowLayout, RowLayout)> {
                 a.extend(above.map(|rect| Placed::Fill { rect, color: *color }));
                 b.extend(below.map(|rect| Placed::Fill { rect, color: *color }));
             }
-            Placed::Cell { rect, table, row: r, cell, story } => {
+            Placed::Cell { rect, covered, table, row: r, cell, story } => {
                 let (above, below) = split_rect(*rect, cut, shift);
-                let cell_at = |rect| Placed::Cell { rect, table: table.clone(), row: *r, cell: *cell, story: *story };
+                let cell_at = |rect| Placed::Cell { rect, covered: *covered, table: table.clone(), row: *r, cell: *cell, story: *story };
                 a.extend(above.map(cell_at));
                 b.extend(below.map(cell_at));
             }
diff --git a/crates/layout/src/tests.rs b/crates/layout/src/tests.rs
index eccf3f5a31..6f9ef2af83 100644
--- a/crates/layout/src/tests.rs
+++ b/crates/layout/src/tests.rs
@@ -234,6 +234,7 @@ fn many_hidden_float_anchors_lay_out_in_linear_time() {
             story: None,
             freeform: None,
             effects: Default::default(),
+            extra: Default::default(),
         };
         let obj = wordcraft_doc::para::OBJ.to_string();
         let mut p = wordcraft_doc::Paragraph::with_text("Text ", Default::default());
@@ -399,7 +400,7 @@ fn right_tab_aligns_text_end() {
 fn lists_get_labels_and_indent() {
     let mut d = Document::from_text("one\ntwo\nthree");
     let id = d.numbering.add_list(wordcraft_doc::ListKind::Numbered);
-    d.format_paragraphs(&Pos::body(0, 0), &Pos::body(2, 0), &|p| p.numbering = Some(wordcraft_doc::props::NumRef { num: id, level: 0 })).unwrap();
+    d.format_paragraphs(&Pos::body(0, 0), &Pos::body(2, 5), &|p| p.numbering = Some(wordcraft_doc::props::NumRef { num: id, level: 0 })).unwrap();
     let l = lay(&d);
     let labels: Vec<String> = l.pages[0]
         .items
@@ -411,6 +412,55 @@ fn lists_get_labels_and_indent() {
     assert!((x - 108.0).abs() < 0.5, "{x}");
 }
 
+#[test]
+fn chinese_counting_list_labels_and_their_font_runs() {
+    // Issue #534: a "一、" list showed digits, drawn with glyph ids of another font.
+    use wordcraft_doc::section::NumFormat;
+    let mut d = Document::from_text("甲\n乙\n丙");
+    let id = d.numbering.add_list(wordcraft_doc::ListKind::Numbered);
+    for a in &mut d.numbering.abstracts {
+        if let Some(l) = a.levels.first_mut() {
+            l.format = NumFormat::ChineseCounting;
+            l.text = "%1、".into();
+        }
+    }
+    d.format_paragraphs(&Pos::body(0, 0), &Pos::body(2, 3), &|p| p.numbering = Some(wordcraft_doc::props::NumRef { num: id, level: 0 })).unwrap();
+    let labels = |d: &Document| -> Vec<(String, Vec<(String, bool)>)> {
+        let l = lay(d);
+        l.pages[0]
+            .items
+            .iter()
+            .filter_map(|it| if let Placed::Lines { para, .. } = it { Some(para.clone()) } else { None })
+            .filter_map(|pl| {
+                let lab = pl.label.clone()?;
+                // Every run draws glyphs of its own face.
+                let runs = lab
+                    .runs
+                    .iter()
+                    .map(|r| {
+                        let face = &pl.styles[r.style as usize].face;
+                        let gids: Vec<u32> = lab.glyphs[r.glyphs.clone()].iter().map(|g| g.gid).collect();
+                        (r.text.clone(), r.text.chars().all(|c| gids.contains(&face.glyph_for(c))))
+                    })
+                    .collect();
+                Some((lab.text, runs))
+            })
+            .collect()
+    };
+    let got = labels(&d);
+    assert_eq!(got.iter().map(|(t, _)| t.as_str()).collect::<Vec<_>>(), ["一、", "二、", "三、"]);
+    // A decimal label next to a CJK comma mixes faces when the Latin face lacks the comma.
+    for a in &mut d.numbering.abstracts {
+        if let Some(l) = a.levels.first_mut() {
+            l.format = NumFormat::Decimal;
+        }
+    }
+    for (text, runs) in labels(&d).into_iter().chain(got) {
+        assert_eq!(runs.iter().map(|(t, _)| t.as_str()).collect::<String>(), text);
+        assert!(runs.iter().all(|(_, own)| *own), "{text}: {runs:?}");
+    }
+}
+
 #[test]
 fn symbol_font_bullet_without_the_font_draws_a_bullet() {
     // Word's default bullet: U+F0B7 in Symbol.
@@ -448,6 +498,29 @@ fn tables_lay_out_cells() {
     assert!(l.cell_at(0, c.x, c.top + 2.0).is_some());
 }
 
+/// A vertical merge is one cell: its box spans the rows, a click anywhere in it finds it, and the
+/// continuation row's box is `covered` (no gridline, not a hit).
+#[test]
+fn a_vertical_merge_lays_out_as_one_cell() {
+    let mut d = Document::from_text("before\nafter");
+    let mut t = Table::new(3, 2, 468.0);
+    t.rows[0].cells[0].props.vmerge = wordcraft_doc::props::VMerge::Restart;
+    t.rows[1].cells[0].props.vmerge = wordcraft_doc::props::VMerge::Continue;
+    d.insert_block(StoryRef::Body, &Path::top(1), wordcraft_doc::Block::Table(t)).unwrap();
+    let l = lay(&d);
+    let cells: Vec<_> = l.pages[0]
+        .items
+        .iter()
+        .filter_map(|i| if let Placed::Cell { rect, row, cell: 0, covered, .. } = i { Some((*row, *rect, *covered)) } else { None })
+        .collect();
+    let (r0, r1) = (cells[0].1, cells[1].1);
+    assert!(!cells[0].2 && cells[1].2 && !cells[2].2, "{cells:?}");
+    assert!((r0.bottom() - r1.bottom()).abs() < 0.01 && r0.h > r1.h * 1.9, "{r0:?} {r1:?}");
+    // The lower half of the merge hits the restart cell (row 0), not the continuation row.
+    let hit = l.cell_at(0, r1.x + 5.0, r1.y + r1.h / 2.0).unwrap();
+    assert_eq!((hit.2, hit.3), (0, 0));
+}
+
 /// A 1×3 table after "before" whose middle cell holds `text` running `dir`.
 fn turned_table(dir: TextDirection, text: &str, row: Option<f32>) -> Document {
     let mut d = Document::from_text("before\nafter");
@@ -863,11 +936,7 @@ fn runs_differing_only_in_link_or_decoration_keep_their_own_style() {
 fn web_view_is_one_page() {
     let d = Document::from_text(&"text ".repeat(3000));
     let mut c = LayoutCache::new();
-    let l = layout(
-        &d,
-        &mut c,
-        &LayoutOptions { view: ViewMode::Web, web_width: 800.0, show_hidden: false, hide_deleted: false, proofing: false, field_codes: false },
-    );
+    let l = layout(&d, &mut c, &LayoutOptions { view: ViewMode::Web, web_width: 800.0, ..Default::default() });
     assert_eq!(l.pages.len(), 1);
     assert!(l.pages[0].h > 800.0);
 }
@@ -1061,6 +1130,7 @@ fn text_wraps_around_square_float() {
         story: None,
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     d.insert_object(&Pos::body(0, 0), shape, &Default::default()).unwrap();
     let l = lay(&d);
@@ -1100,6 +1170,7 @@ fn deleted_float_leaves_no_wrap_area_without_markup() {
         story: None,
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     d.insert_object(&Pos::body(0, 0), shape, &Default::default()).unwrap();
     let obj = wordcraft_doc::para::OBJ.len_utf8();
@@ -1153,6 +1224,7 @@ fn hidden_float_leaves_no_wrap_area_when_hidden_text_is_not_shown() {
         story: None,
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     d.insert_object(&Pos::body(0, 0), shape, &Default::default()).unwrap();
     let obj = wordcraft_doc::para::OBJ.len_utf8();
@@ -1207,6 +1279,7 @@ fn line_numbers_borders_text_boxes() {
         story: Some(id),
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     d.insert_object(&Pos::body(2, 5), tb, &Default::default()).unwrap();
     let l = lay(&d);
@@ -1385,6 +1458,32 @@ fn auto_hyphenation_breaks_long_words() {
     let _ = hyphens(&l2);
 }
 
+/// Hyphenation Options (#407): a consecutive-hyphen limit of 1 never lets two lines in a row end
+/// with a hyphen, and words in capitals stay whole when the document says so.
+#[test]
+fn hyphenation_options_limit_hyphens_and_spare_capitals() {
+    let text = "Internationalization considerations notwithstanding, administrators systematically reconsidered extraordinarily uncharacteristic responsibilities. ".repeat(6);
+    let lines = |d: &Document| -> Vec<bool> {
+        lay(d).pages[0]
+            .items
+            .iter()
+            .filter_map(|i| {
+                if let Placed::Lines { para, .. } = i { Some(para.lines.iter().map(|x| x.hyphen.is_some()).collect::<Vec<_>>()) } else { None }
+            })
+            .flatten()
+            .collect()
+    };
+    let mut d = Document::from_text(&text);
+    d.settings.auto_hyphenation = true;
+    d.settings.consecutive_hyphen_limit = 1;
+    let hy = lines(&d);
+    assert!(hy.windows(2).all(|w| !(w[0] && w[1])), "two hyphenated lines in a row: {hy:?}");
+    let mut caps = Document::from_text(&text.to_uppercase());
+    caps.settings.auto_hyphenation = true;
+    caps.settings.hyphenate_caps = false;
+    assert!(lines(&caps).iter().all(|h| !h), "a word in capitals was hyphenated");
+}
+
 /// A table of `rows` x 2 with text in every cell, after a "before" paragraph.
 fn styled_table_doc(style: Option<&str>, rows: usize) -> Document {
     let mut d = Document::from_text("before\nafter");
@@ -1520,6 +1619,7 @@ fn text_box_at(d: &mut Document, pos: &Pos, text: &str, w: f32, h: f32, float: w
         story: Some(id),
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     d.insert_object(pos, shape, &Default::default()).unwrap();
     id
@@ -1592,6 +1692,7 @@ fn presses_grab_pictures_anywhere_and_text_boxes_by_their_border() {
         story: None,
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     d.insert_object(&Pos::body(0, 0), shape, &Default::default()).unwrap();
     let l = lay(&d);
@@ -1813,6 +1914,7 @@ fn box_fan_out(levels: usize, fan: usize) -> Document {
         story: Some(story),
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     };
     for (k, id) in ids.iter().enumerate() {
         let next = *ids.get(k + 1).unwrap_or(id);
@@ -1887,6 +1989,7 @@ fn picture(w: f32, h: f32, float: wordcraft_doc::para::Float) -> InlineObject {
         story: None,
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     }
 }
 
@@ -1907,6 +2010,40 @@ fn line_spacing_does_not_scale_pictures() {
     assert!((line.baseline - line.top - 144.0).abs() < 0.01, "the picture stands on the baseline");
 }
 
+#[test]
+fn multiple_line_spacing_adds_its_leading_below_the_text() {
+    use wordcraft_doc::props::LineSpacing;
+    // (spacing, expected baseline below the line top as a share of the ascent)
+    for (spacing, share) in [(LineSpacing::Multiple(1.15), 1.0), (LineSpacing::Multiple(2.0), 1.0), (LineSpacing::Multiple(0.8), 0.8)] {
+        let mut d = Document::from_text(&"Several words wrap onto more lines. ".repeat(30));
+        if let Some(wordcraft_doc::Block::Para(p)) = d.body.get_mut(0).map(std::sync::Arc::make_mut) {
+            p.props.line_spacing = Some(spacing);
+        }
+        let l = lay(&d);
+        let Some(Placed::Lines { para, .. }) = l.pages[0].items.iter().find(|i| matches!(i, Placed::Lines { .. })) else { panic!() };
+        let asc = para.styles[0].ascent;
+        assert!(para.lines.len() > 1);
+        for line in &para.lines {
+            // Word's 1.15-spaced Times New Roman 12pt sits one ascent below the line top; the
+            // 0.15 extra goes below the descent (docxide-pdf's hyphenation fixtures).
+            assert!(
+                (line.baseline - line.top - asc * share).abs() < 0.01,
+                "{spacing:?}: baseline {} below the top, ascent {asc}",
+                line.baseline - line.top
+            );
+        }
+    }
+    // Exact spacing still keeps the descent below the baseline.
+    let mut d = Document::from_text("Exact");
+    if let Some(wordcraft_doc::Block::Para(p)) = d.body.get_mut(0).map(std::sync::Arc::make_mut) {
+        p.props.line_spacing = Some(LineSpacing::Exactly(30.0));
+    }
+    let l = lay(&d);
+    let Some(Placed::Lines { para, .. }) = l.pages[0].items.iter().find(|i| matches!(i, Placed::Lines { .. })) else { panic!() };
+    let line = &para.lines[0];
+    assert!((line.top + line.height - line.baseline - para.styles[0].descent).abs() < 0.01);
+}
+
 #[test]
 fn body_starts_right_below_a_tall_header() {
     let mut d = Document::from_text("Body");
@@ -2036,6 +2173,7 @@ fn rect_shape(w: f32, h: f32, float: wordcraft_doc::para::Float) -> InlineObject
         story: None,
         freeform: None,
         effects: Default::default(),
+        extra: Default::default(),
     }
 }
 
@@ -2206,6 +2344,7 @@ fn floating_header_text_box_leaves_the_body_at_the_top_margin() {
                 story: Some(story),
                 freeform: None,
                 effects: Default::default(),
+                extra: Default::default(),
             };
             anchor.insert_object(0, tb, &Default::default()).unwrap();
         }
@@ -2359,6 +2498,74 @@ fn a_floating_table_taller_than_a_page_runs_across_pages() {
     assert_eq!(rows, 80);
 }
 
+/// #534: a table placed on the page (`w:tblpPr w:vertAnchor="page"`) whose anchor comes after a
+/// page full of text goes to the next page with it, like Word, instead of covering that text.
+#[test]
+fn a_page_anchored_floating_table_after_a_full_page_moves_to_the_next() {
+    use wordcraft_doc::para::Anchor;
+    use wordcraft_doc::props::TableFloat;
+    let text: Vec<String> = (0..24).map(|i| format!("Paragraph {i} before the table.")).collect();
+    let mut d = Document::from_text(&(text.join("\n") + "\nAfter the table."));
+    let mut t = Table::new(15, 1, 300.0);
+    for (i, r) in t.rows.iter_mut().enumerate() {
+        r.cells[0].blocks = vec![wordcraft_doc::para_block(wordcraft_doc::Paragraph::with_text(&format!("Row {i}"), Default::default()))];
+    }
+    t.props.float = Some(TableFloat { h_rel: Anchor::Page, v_rel: Anchor::Page, x: 70.0, y: 71.0, ..Default::default() });
+    d.insert_block(StoryRef::Body, &Path::top(24), wordcraft_doc::Block::Table(t)).unwrap();
+    let l = lay(&d);
+    let page_of = |want: &dyn Fn(&Path) -> bool| -> Vec<usize> {
+        l.pages
+            .iter()
+            .enumerate()
+            .flat_map(|(i, p)| p.items.iter().map(move |it| (i, it)))
+            .filter_map(|(i, it)| if let Placed::Lines { story: StoryRef::Body, path, .. } = it { want(path).then_some(i) } else { None })
+            .collect()
+    };
+    // The text before the table fills page 1; the table and the text after it are on page 2.
+    assert_eq!(page_of(&|p| p.0 == [23]), vec![0]);
+    let rows = page_of(&|p| p.0.first() == Some(&24) && p.0.len() > 1);
+    assert!(rows.len() == 15 && rows.iter().all(|pg| *pg == 1), "table rows on pages {rows:?}");
+    assert_eq!(page_of(&|p| p.0 == [25]), vec![1]);
+}
+
+/// #534: a paragraph that starts with a page break right where the page is full keeps the break
+/// on that page: no blank page between the two tables around it.
+#[test]
+fn a_page_break_at_the_bottom_of_a_full_page_leaves_no_blank_page() {
+    use wordcraft_doc::props::LineSpacing;
+    let props = ParaProps { line_spacing: Some(LineSpacing::Exactly(24.0)), space_before: Some(0.0), space_after: Some(0.0), ..Default::default() };
+    let para = |text: &str| {
+        let mut p = wordcraft_doc::Paragraph::with_text(text, Default::default());
+        p.props = props.clone();
+        wordcraft_doc::para_block(p)
+    };
+    let mut d = Document::from_text("");
+    // 27 lines of 24pt fill the 648pt of text on a Letter page.
+    d.body = (0..27).map(|i| para(&format!("Line {i}"))).collect();
+    d.body.push(para("\u{000C}Next page"));
+    let l = lay(&d);
+    assert_eq!(l.pages.len(), 2, "pages: {}", l.pages.len());
+    let last_on_2 = l.pages[1].items.iter().any(|it| matches!(it, Placed::Lines { path, .. } if path.0 == [27]));
+    assert!(last_on_2, "the text after the break is on page 2");
+}
+
+/// #534: indents in characters (`w:firstLineChars`) are measured in the paragraph mark's font
+/// size and win over the indent in points.
+#[test]
+fn character_indents_use_the_paragraph_mark_size() {
+    let mut p = wordcraft_doc::Paragraph::with_text(&"字".repeat(80), Default::default());
+    p.props.indent_first = Some(5.0);
+    p.props.indent_first_chars = Some(2.0);
+    p.props.indent_left_chars = Some(1.0);
+    p.mark.size = Some(20.0);
+    let mut d = Document::from_text("");
+    d.body = vec![wordcraft_doc::para_block(p)];
+    let l = lay(&d);
+    let para = l.pages[0].items.iter().find_map(|it| if let Placed::Lines { para, .. } = it { Some(para.clone()) } else { None }).unwrap();
+    assert!((para.lines[0].left - 60.0).abs() < 0.01, "first line at {}", para.lines[0].left);
+    assert!((para.lines[1].left - 20.0).abs() < 0.01, "second line at {}", para.lines[1].left);
+}
+
 #[test]
 fn no_line_break_right_after_a_slash() {
     // Word keeps "and/or" and web addresses whole on a line when they fit.
@@ -2599,7 +2806,7 @@ fn oversized_graphic_draws_shrunk_with_its_items() {
         stroke: Some(Rgb::BLACK),
         stroke_width: 4.0,
     }];
-    let graphic = Graphic { kind: GraphicKind::Chart, items, w: 1000.0, h: 500.0, source: None };
+    let graphic = Graphic { kind: GraphicKind::Chart, items, w: 1000.0, h: 500.0, source: None, chart: None, smart_art: None };
     let obj = InlineObject::Graphic { w: 1000.0, h: 500.0, alt: String::new(), float: Default::default(), graphic: Arc::new(graphic) };
     let mut d = Document::from_text("Chart");
     d.insert_object(&Pos::body(0, 0), obj, &Default::default()).unwrap();
@@ -2816,6 +3023,7 @@ fn rotated_float_wraps_around_its_rotated_bounds() {
             story: None,
             freeform: None,
             effects: Default::default(),
+            extra: Default::default(),
         };
         d.insert_object(&Pos::body(0, 0), shape, &Default::default()).unwrap();
         let l = layout(&d, &mut LayoutCache::new(), &LayoutOptions::default());
@@ -2860,6 +3068,7 @@ fn rotated_group_turns_its_members_and_their_shadows() {
         story: None,
         freeform: None,
         effects: ShapeEffects { shadow: Some(Shadow { angle: 0.0, rot_with_shape, ..Default::default() }), ..Default::default() },
+        extra: Default::default(),
     };
     let float =
         Float { wrap: Wrap::InFrontOfText, h_rel: Anchor::Column, v_rel: Anchor::Paragraph, x: 100.0, y: 100.0, rot: 90.0, ..Default::default() };
@@ -2997,6 +3206,104 @@ fn footnote_longer_than_pages_ends() {
     assert!(pieces.windows(2).all(|w| w[0].2 == w[1].1 && w[1].0 == w[0].0 + 1), "{pieces:?}");
 }
 
+/// A comment by `author` saying `text` on body paragraph `para`, bytes `a..b`; its id.
+fn comment_on(d: &mut Document, para: usize, a: usize, b: usize, author: &str, text: &str, parent: Option<u32>) -> u32 {
+    let part = d.add_part(wordcraft_doc::PartKind::Comment, vec![wordcraft_doc::para_block(Paragraph::with_text(text, CharProps::default()))]);
+    let id = d.comments.keys().next_back().map_or(0, |k| k + 1);
+    d.comments.insert(id, wordcraft_doc::Comment { author: author.into(), part, parent, ..Default::default() });
+    if parent.is_none() {
+        let p = CharProps::default();
+        d.insert_object(&Pos::body(para, b), InlineObject::CommentEnd { id }, &p).unwrap();
+        d.insert_object(&Pos::body(para, a), InlineObject::CommentStart { id }, &p).unwrap();
+    }
+    id
+}
+
+fn balloon_layout(d: &Document) -> DocLayout {
+    layout(d, &mut LayoutCache::new(), &LayoutOptions { comment_balloons: true, ..Default::default() })
+}
+
+/// The comment text lines placed on page `pi` (story, top-left).
+fn comment_lines(l: &DocLayout, pi: usize) -> Vec<(StoryRef, f32, f32)> {
+    l.pages[pi]
+        .items
+        .iter()
+        .filter_map(|it| match it {
+            Placed::Lines { story: s @ StoryRef::Part(_), x, y, .. } => Some((*s, *x, *y)),
+            _ => None,
+        })
+        .collect()
+}
+
+/// Print Markup (#589): each page grows by the markup area, and the comment, its author and its
+/// reply are laid out there beside the line they comment on.
+#[test]
+fn comment_balloons_widen_pages_beside_their_anchors() {
+    let mut d = Document::from_text("Intro line.\nThe quarterly figures look strong.\nClosing line.");
+    let id = comment_on(&mut d, 1, 4, 13, "Ada Reviewer", "Check the totals", None);
+    comment_on(&mut d, 0, 0, 0, "Ben Editor", "Totals checked", Some(id));
+    let plain = lay(&d);
+    let l = balloon_layout(&d);
+    assert_eq!(l.pages.len(), plain.pages.len());
+    let (w, pw) = (l.pages[0].w, plain.pages[0].w);
+    assert_eq!(l.pages[0].markup, balloons::MARKUP_AREA);
+    assert!((w - pw - balloons::MARKUP_AREA).abs() < 0.01, "{w} vs {pw}");
+    assert_eq!(plain.pages[0].markup, 0.0);
+    // Author + text for the comment, then for the reply: four lines, all in the markup area.
+    let lines = comment_lines(&l, 0);
+    assert_eq!(lines.len(), 4, "{lines:?}");
+    assert!(lines.iter().all(|(_, x, _)| *x > pw && *x < w), "{lines:?}");
+    assert!(lines.windows(2).all(|p| p[0].2 < p[1].2), "stacked top to bottom: {lines:?}");
+    // The card sits by the commented line.
+    let anchor = l.caret(&Pos::body(1, 5)).unwrap();
+    assert!((lines[0].2 - anchor.top).abs() < 30.0, "{lines:?} vs {anchor:?}");
+    // The body is laid out exactly as without balloons.
+    assert_eq!(lines_of(&plain), lines_of(&l) - 4);
+    // The leader starts at the anchor.
+    assert!(l.pages[0].items.iter().any(|it| matches!(it, Placed::Rule { x0, x1, .. } if (*x0 - anchor.x).abs() < 0.5 && (*x1 - pw).abs() < 0.5)));
+}
+
+#[test]
+fn no_balloons_without_anchored_comments() {
+    let d = Document::from_text("No comments here.");
+    let l = balloon_layout(&d);
+    assert_eq!(l.pages[0].markup, 0.0);
+    assert_eq!(l.pages[0].w, lay(&d).pages[0].w);
+    // A web view never gets a markup area.
+    let mut d = Document::from_text("Hello there.");
+    comment_on(&mut d, 0, 0, 5, "A", "x", None);
+    let opts = LayoutOptions { view: ViewMode::Web, web_width: 500.0, comment_balloons: true, ..Default::default() };
+    let l = layout(&d, &mut LayoutCache::new(), &opts);
+    assert_eq!(l.pages[0].markup, 0.0);
+}
+
+/// Hostile comments: parent cycles, a missing text part, and far more comments than fit beside
+/// one page. Nothing panics or hangs, and the cards stay on the page.
+#[test]
+fn comment_balloons_survive_hostile_comments() {
+    let mut d = Document::from_text(&"Commented words here. ".repeat(20));
+    let mut ids = Vec::new();
+    for i in 0..120 {
+        ids.push(comment_on(&mut d, 0, 0, 9, &format!("Author {i}"), &"A long remark that wraps over lines. ".repeat(4), None));
+    }
+    // A reply cycle and a comment whose text part is gone.
+    let a = comment_on(&mut d, 0, 0, 0, "R", "one", Some(ids[0]));
+    let b = comment_on(&mut d, 0, 0, 0, "R", "two", Some(a));
+    d.comments.get_mut(&a).unwrap().parent = Some(b);
+    d.comments.get_mut(&ids[1]).unwrap().parent = Some(ids[1]);
+    d.comments.get_mut(&ids[2]).unwrap().part = 9_999_999;
+    let l = balloon_layout(&d);
+    let page = &l.pages[0];
+    for (_, _, y) in comment_lines(&l, 0) {
+        assert!(y.is_finite() && y >= 0.0 && y <= page.h, "{y}");
+    }
+    for it in &page.items {
+        if let Placed::Fill { rect, .. } = it {
+            assert!(rect.y >= 0.0 && rect.bottom() <= page.h + 0.5, "{rect:?}");
+        }
+    }
+}
+
 /// The first paragraph's lines on page one: (top, bottom, left, right), relative to its column.
 fn line_spans(l: &DocLayout) -> Vec<(f32, f32, f32, f32)> {
     let Some(Placed::Lines { para, .. }) = l.pages[0].items.iter().find(|i| matches!(i, Placed::Lines { .. })) else { return Vec::new() };
@@ -3019,6 +3326,7 @@ fn wrapped_shape_doc(kind: wordcraft_doc::para::ShapeKind, w: f32, h: f32, float
         story: None,
         effects: Default::default(),
         freeform: None,
+        extra: Default::default(),
     };
     d.insert_object(&Pos::body(0, 0), shape, &Default::default()).unwrap();
     d
@@ -3283,6 +3591,7 @@ fn rotated_canvas_draws_its_clipped_members_inside_the_turn() {
         story: None,
         effects: Default::default(),
         freeform: None,
+        extra: Default::default(),
     };
     let canvas = |float: Float| InlineObject::Group {
         w: 200.0,
@@ -3356,6 +3665,26 @@ fn rotated_canvas_draws_its_clipped_members_inside_the_turn() {
     }
 }
 
+#[test]
+fn mirror_indents_swap_sides_on_even_pages() {
+    // #512: with mirrored indents the left indent is the inside one, on the right of an even page.
+    let mut d = Document::from_text("odd page\neven page");
+    let last = Pos::body(1, 0);
+    d.format_paragraphs(&Pos::body(0, 0), &last, &|p| {
+        p.indent_left = Some(72.0);
+        p.mirror_indents = Some(true);
+    })
+    .unwrap();
+    d.format_paragraphs(&last, &last, &|p| p.page_break_before = Some(true)).unwrap();
+    let l = lay(&d);
+    assert_eq!(l.pages.len(), 2);
+    let odd = l.caret(&Pos::body(0, 0)).unwrap();
+    let even = l.caret(&last).unwrap();
+    assert_eq!(even.page, 1);
+    assert!((odd.x - 144.0).abs() < 0.5, "odd page: inside indent on the left, {odd:?}");
+    assert!((even.x - 72.0).abs() < 0.5, "even page: the left side has the outside indent (0), {even:?}");
+}
+
 /// Ten short paragraphs in a two-column section (`widths`: unequal columns), then one paragraph
 /// in a one-column section starting `start`.
 fn two_column_section(start: wordcraft_doc::section::SectionStart, widths: Vec<(f32, f32)>) -> Document {
@@ -3530,7 +3859,7 @@ fn hyphenation_and_proofing_follow_each_runs_language() {
     assert_eq!(flagged, ["żeka", "beautifull"]);
     // The layout and the Review commands report the same issues.
     let p = d.para(StoryRef::Body, &Path::top(0)).unwrap();
-    let issues = para::paragraph_issues(p, &para::proof_runs(&d, p, None));
+    let issues = para::paragraph_issues(p, &para::proof_runs(&d, p, None), &Default::default(), true);
     assert_eq!(issues.iter().map(|i| (i.start, i.end, i.kind == wordcraft_proof::IssueKind::Grammar)).collect::<Vec<_>>(), para.issues);
     assert_eq!(issues[0].lang, wordcraft_proof::ProofLang::Pl);
     assert_eq!(issues[1].lang, wordcraft_proof::ProofLang::En);
@@ -3559,3 +3888,121 @@ fn unproofed_languages_and_no_proof_runs_are_not_marked() {
     pl.format_range(&Pos::body(0, 0), &Pos::body(0, "Płynie żeka.".len()), &|c| c.no_proof = Some(true)).unwrap();
     assert_eq!(issues(&pl), 0);
 }
+
+/// #451: page totals in the body show the document's page count (the stale cached result is
+/// ignored), on every page, like the same fields in the footer.
+#[test]
+fn body_page_totals_count_every_page() {
+    let mut d = Document::from_text("Body-1\nBody-2\nBody-3");
+    let field = |instr: &str| InlineObject::Field { instr: instr.into(), result: "9".into(), locked: false, code: false };
+    for i in 0..3 {
+        let p = d.para_mut(StoryRef::Body, &Path::top(i)).unwrap();
+        p.props.page_break_before = Some(i > 0);
+        let n = p.len();
+        p.insert_object(n, field("NUMPAGES"), &Default::default()).unwrap();
+        let n = p.len();
+        p.insert_object(n, field("SECTIONPAGES"), &Default::default()).unwrap();
+    }
+    let mut fp = wordcraft_doc::Paragraph::new();
+    fp.insert_object(0, field("NUMPAGES"), &Default::default()).unwrap();
+    let id = d.add_part(wordcraft_doc::PartKind::Footer, vec![wordcraft_doc::para_block(fp)]);
+    d.last_section.footers.default = Some(id);
+    let l = lay(&d);
+    assert_eq!(l.pages.len(), 3);
+    let shown = |items: &[Placed]| -> Vec<String> {
+        items
+            .iter()
+            .flat_map(|it| if let Placed::Lines { para, .. } = it { para.shown.iter().map(|s| s.1.clone()).collect() } else { vec![] })
+            .collect()
+    };
+    for (i, p) in l.pages.iter().enumerate() {
+        assert_eq!(shown(&p.items), ["3", "3"], "body of page {}", i + 1);
+        assert_eq!(shown(&p.footer), ["3"], "footer of page {}", i + 1);
+    }
+    // One page: one pass, total 1.
+    let mut d1 = Document::from_text("Only");
+    let p = d1.para_mut(StoryRef::Body, &Path::top(0)).unwrap();
+    p.insert_object(4, field("NUMPAGES"), &Default::default()).unwrap();
+    assert_eq!(shown(&lay(&d1).pages[0].items), ["1"]);
+}
+
+/// #450: a footnote referenced in a table cell is placed at the bottom of its page, like one in
+/// a body paragraph.
+#[test]
+fn table_cell_footnotes_are_placed() {
+    let mut d = Document::from_text("After the table.");
+    d.insert_block(StoryRef::Body, &Path::top(0), wordcraft_doc::Block::Table(wordcraft_doc::Table::new(1, 1, 300.0))).unwrap();
+    let cell = Pos { story: StoryRef::Body, path: Path(vec![0, 0, 0, 0]), off: 0 };
+    d.para_mut(StoryRef::Body, &cell.path).unwrap().insert_text(0, "Table reference", &Default::default()).unwrap();
+    let id = footnote(&mut d, &Pos { off: "Table reference".len(), ..cell }, "Table note payload.");
+    let l = lay(&d);
+    assert_eq!(l.pages.len(), 1);
+    let c = l.caret(&d.start_of(StoryRef::Part(id))).expect("the cell's footnote is placed");
+    assert_eq!(c.page, 0);
+    let body = l.caret(&Pos::body(1, 0)).unwrap();
+    assert!(c.top > body.top + 100.0, "at the page bottom: {c:?} {body:?}");
+}
+
+#[test]
+fn east_asian_text_takes_the_asian_font_and_latin_text_the_latin_font() {
+    // #505: one run with a Latin font and an Asian font (w:eastAsia) of its own sets each script in
+    // its font. Prefer an installed CJK font other than the one fallback would pick anyway.
+    let resolve = |f: &str| wordcraft_fonts::word::resolve(f, false, false);
+    let fallback = wordcraft_fonts::FontDb::global().fallback_for('你', 0).map(|f| f.family.clone());
+    let mut fonts: Vec<String> = wordcraft_fonts::FontDb::global()
+        .east_asian_families()
+        .into_iter()
+        .filter(|f| {
+            let r = resolve(f);
+            !r.substituted && r.face.covers('你') && r.face.covers('好')
+        })
+        .collect();
+    fonts.sort_by_key(|f| Some(f) == fallback.as_ref());
+    let Some(asian) = fonts.first().cloned() else {
+        eprintln!("skipped: no Chinese font installed");
+        return;
+    };
+    let latin = wordcraft_doc::styles::BODY_FONT;
+    let text = "Hello 你好 World";
+    let mut d = Document::from_text(text);
+    d.format_range(&Pos::body(0, 0), &Pos::body(0, text.len()), &|c| {
+        c.font = Some(latin.into());
+        c.font_ea = Some(asian.clone());
+    })
+    .unwrap();
+    let l = lay(&d);
+    let para =
+        l.pages.iter().flat_map(|p| p.items.iter()).find_map(|it| if let Placed::Lines { para, .. } = it { Some(para) } else { None }).unwrap();
+    let (latin_face, asian_face) = (resolve(latin).face.id(), resolve(&asian).face.id());
+    for c in &para.clusters {
+        let Some(ch) = text.get(c.start..c.end).and_then(|s| s.chars().next()).filter(|ch| !ch.is_whitespace()) else { continue };
+        let face = para.styles[c.style as usize].face.id();
+        let want = if ch.is_ascii() { latin_face } else { asian_face };
+        assert_eq!(face, want, "{ch:?} in {}", if ch.is_ascii() { latin } else { &asian });
+    }
+}
+
+/// A page total in the footer ("Page X of Y") is filled in after pagination, so it doesn't make
+/// the body lay out a second time; one in the body still does.
+#[test]
+fn footer_page_total_needs_one_body_pass() {
+    let field = || InlineObject::Field { instr: "NUMPAGES".into(), result: "9".into(), locked: false, code: false };
+    let mut d = Document::from_text("Body-1\nBody-2\nBody-3");
+    for i in 1..3 {
+        d.para_mut(StoryRef::Body, &Path::top(i)).unwrap().props.page_break_before = Some(true);
+    }
+    let mut fp = wordcraft_doc::Paragraph::new();
+    fp.insert_object(0, field(), &Default::default()).unwrap();
+    let id = d.add_part(wordcraft_doc::PartKind::Footer, vec![wordcraft_doc::para_block(fp)]);
+    d.last_section.footers.default = Some(id);
+    let first = |d: &Document| {
+        let totals = Totals::first_guess(d.sections().len());
+        layout_pass(d, &mut LayoutCache::new(), &LayoutOptions::default(), &HashMap::new(), &totals, true)
+    };
+    assert!(matches!(first(&d), Pass::Done(l) if l.pages.len() == 3), "the footer's total asked for another pass");
+    // The same field in the body is only known once every page is laid out.
+    let p = d.para_mut(StoryRef::Body, &Path::top(0)).unwrap();
+    let n = p.len();
+    p.insert_object(n, field(), &Default::default()).unwrap();
+    assert!(matches!(first(&d), Pass::Again(t) if t.pages == 3));
+}
diff --git a/crates/layout/src/tests_complex.rs b/crates/layout/src/tests_complex.rs
new file mode 100644
index 0000000000..d8e6b693f0
--- /dev/null
+++ b/crates/layout/src/tests_complex.rs
@@ -0,0 +1,111 @@
+//! Complex scripts that reorder and stack (#604): Myanmar, Khmer, Devanagari. Cluster and line
+//! breaking tests don't depend on installed fonts (a missing font draws .notdef boxes, but the
+//! clusters and breaks are the same); shaping tests use a system font when one is installed.
+
+use super::*;
+use wordcraft_doc::{Pos, StoryRef};
+
+fn lay(doc: &Document) -> DocLayout {
+    let mut c = LayoutCache::new();
+    layout(doc, &mut c, &LayoutOptions::default())
+}
+
+/// Body paragraph `i`'s layout.
+fn para_layout(l: &DocLayout, i: u32) -> &ParaLayout {
+    for p in &l.pages {
+        for it in &p.items {
+            if let Placed::Lines { story: StoryRef::Body, path, para, .. } = it
+                && path.0 == vec![i]
+            {
+                return para;
+            }
+        }
+    }
+    panic!("paragraph {i} not laid out");
+}
+
+/// "မြန်မာစာ": the syllables မြ | န် | မာ | စာ.
+const MYANMAR: &str = "\u{1019}\u{103C}\u{1014}\u{103A}\u{1019}\u{102C}\u{1005}\u{102C}";
+
+#[test]
+fn myanmar_syllables_are_single_clusters() {
+    let l = lay(&Document::from_text(MYANMAR));
+    let pl = para_layout(&l, 0);
+    let starts: Vec<usize> = pl.clusters.iter().map(|c| c.start).collect();
+    // Grapheme clusters would also start at the aa signs (bytes 15 and 21), splitting မာ and စာ.
+    assert_eq!(starts, vec![0, 6, 12, 18]);
+    // The caret can't land inside a syllable: every caret offset is a cluster start or the end.
+    let offs = pl.line_offsets(0);
+    assert!(!offs.contains(&15) && !offs.contains(&21), "{offs:?}");
+    // Stacked consonants (virama) and Khmer subscripts (coeng) too.
+    let l = lay(&Document::from_text("\u{1019}\u{1039}\u{1018}\u{102C} \u{1781}\u{17D2}\u{1798}\u{17C2}\u{179A}"));
+    let pl = para_layout(&l, 0);
+    let starts: Vec<usize> = pl.clusters.iter().map(|c| c.start).collect();
+    assert_eq!(starts, vec![0, 12, 13, 25]);
+}
+
+#[test]
+fn myanmar_without_spaces_wraps_between_syllables() {
+    let text = MYANMAR.repeat(80);
+    let l = lay(&Document::from_text(&text));
+    let pl = para_layout(&l, 0);
+    assert!(pl.lines.len() > 1, "a long Myanmar paragraph wraps");
+    let breaks = wordcraft_doc::cluster::myanmar_breaks(&text);
+    // A line may end before each syllable: before မာ and စာ, never before န် (a final).
+    for c in &pl.clusters {
+        assert_eq!(c.break_after, breaks.contains(&c.end), "break after {}", c.end);
+    }
+    assert!(pl.clusters.iter().any(|c| c.break_after && c.end == 12) && !pl.clusters.iter().any(|c| c.break_after && c.end == 6));
+    for line in pl.lines.iter().skip(1) {
+        let start = pl.clusters[line.c0].start;
+        assert!(breaks.contains(&start), "line starts at syllable {start}");
+    }
+    // Lines are full: a syllable break, not an emergency break after one cluster.
+    assert!(pl.lines[0].c1 - pl.lines[0].c0 > 10);
+}
+
+/// A face with Myanmar letters (an installed system font), or `None` to skip.
+fn myanmar_face() -> Option<wordcraft_fonts::FaceRef> {
+    wordcraft_fonts::FontDb::global().fallback_for('\u{1000}', 0).map(|f| wordcraft_fonts::FaceRef::of(&f)).filter(|f| f.has_layout_tables())
+}
+
+#[test]
+fn myanmar_prevowel_is_drawn_before_its_consonant() {
+    let Some(face) = myanmar_face() else {
+        eprintln!("skipped: no Myanmar font with OpenType tables installed");
+        return;
+    };
+    // ကေ: in memory consonant first, on screen the vowel sign ေ first.
+    let ka = face.glyph_for('\u{1000}');
+    let g = wordcraft_fonts::shape(&face, "\u{1000}\u{1031}", &[], |c| c);
+    assert_eq!(g.len(), 2, "{g:?}");
+    assert_eq!(g[1].gid, ka, "the consonant is drawn second: {g:?}");
+    assert!(g.iter().all(|x| x.cluster == 0), "one cluster: {g:?}");
+    // Itemised by script: the same syllable after Latin text in the same face shapes the same
+    // (shaped as one Latin run, the vowel sign would stay after the consonant).
+    if face.covers('H') {
+        let mixed = wordcraft_fonts::shape(&face, "Hi \u{1000}\u{1031}", &[], |c| c);
+        let tail: Vec<u32> = mixed.iter().filter(|x| x.cluster >= 3).map(|x| x.gid).collect();
+        assert_eq!(tail, g.iter().map(|x| x.gid).collect::<Vec<_>>());
+    }
+}
+
+#[test]
+fn myanmar_in_a_latin_font_falls_back_to_a_regular_myanmar_face() {
+    if myanmar_face().is_none() {
+        eprintln!("skipped: no Myanmar font with OpenType tables installed");
+        return;
+    }
+    let l = lay(&Document::from_text(MYANMAR));
+    let pl = para_layout(&l, 0);
+    let faces: Vec<_> = pl.clusters.iter().map(|c| pl.styles[c.style as usize].face).collect();
+    assert!(faces.windows(2).all(|w| w[0].id() == w[1].id()), "one face for the word");
+    let f = faces[0];
+    assert!(f.has_layout_tables(), "{} can reorder Myanmar", f.family);
+    assert!(!f.italic && (f.weight - 400.0).abs() <= 100.0, "a regular weight, not {} {}", f.family, f.style);
+    assert!(pl.glyphs.iter().all(|g| g.gid != 0), "no missing glyphs");
+    // The caret after the first syllable sits after its glyphs.
+    let x6 = l.caret(&Pos::body(0, 6)).map(|c| c.x).unwrap_or(0.0);
+    let x0 = l.caret(&Pos::body(0, 0)).map(|c| c.x).unwrap_or(0.0);
+    assert!(x6 > x0);
+}
diff --git a/crates/layout/src/tests_pages.rs b/crates/layout/src/tests_pages.rs
new file mode 100644
index 0000000000..15b69e206b
--- /dev/null
+++ b/crates/layout/src/tests_pages.rs
@@ -0,0 +1,156 @@
+//! Page geometry: mirrored margins, headers and footers taller than their margin (also when
+//! linked to the previous section), endnotes continuing over pages, and the caret in a footnote
+//! continued on the next page.
+use super::*;
+use wordcraft_doc::para::{InlineObject, NoteKind};
+use wordcraft_doc::{PartKind, Pos, para_block};
+
+fn lay(doc: &Document) -> DocLayout {
+    let mut c = LayoutCache::new();
+    layout(doc, &mut c, &LayoutOptions::default())
+}
+
+fn paras(text: &str, n: usize) -> Vec<Arc<Block>> {
+    (1..=n).map(|i| para_block(Paragraph::with_text(&format!("{text} {i}"), Default::default()))).collect()
+}
+
+/// Top and bottom of the lines of `story` among `items`.
+fn extent(items: &[Placed], story: StoryRef) -> Option<(f32, f32)> {
+    items
+        .iter()
+        .filter_map(|it| match it {
+            Placed::Lines { story: s, y, para, l0, l1, .. } if *s == story => Some((*y, item_bottom(*y, para, *l0, *l1)?)),
+            _ => None,
+        })
+        .reduce(|a, b| (a.0.min(b.0), a.1.max(b.1)))
+}
+
+/// The left edge of the body text on each page.
+fn body_left(l: &DocLayout) -> Vec<f32> {
+    l.pages
+        .iter()
+        .map(|p| p.items.iter().find_map(|it| if let Placed::Lines { story: StoryRef::Body, x, .. } = it { Some(*x) } else { None }).unwrap())
+        .collect()
+}
+
+#[test]
+fn mirrored_margins_put_the_inside_margin_toward_the_binding() {
+    // #452: inside 108 (plus a 10pt gutter), outside 36. Odd pages: inside on the left; even
+    // pages: on the right.
+    let mut d = Document::from_text(&"Body line\n".repeat(90));
+    d.last_section.margin_left = 108.0;
+    d.last_section.margin_right = 36.0;
+    d.last_section.gutter = 10.0;
+    let plain = body_left(&lay(&d));
+    assert!(plain.len() >= 2 && plain.iter().all(|x| (x - 118.0).abs() < 0.01), "not mirrored: {plain:?}");
+    d.settings.mirror_margins = true;
+    let l = lay(&d);
+    let lefts = body_left(&l);
+    for (i, (x, p)) in lefts.iter().zip(&l.pages).enumerate() {
+        let want = if p.number % 2 == 1 { 118.0 } else { 36.0 };
+        assert!((x - want).abs() < 0.01, "page {i} (number {}): text at {x}, want {want}", p.number);
+        assert!((p.body.x - want).abs() < 0.01 && (p.body.w - d.last_section.text_width()).abs() < 0.01, "page {i}: {:?}", p.body);
+    }
+}
+
+#[test]
+fn a_tall_footer_pushes_the_body_up() {
+    // #453: an eight-line footer reaches far above the 72pt bottom margin.
+    let mut d = Document::from_text(&"Body line\n".repeat(60));
+    let id = d.add_part(PartKind::Footer, paras("Footer line", 8));
+    d.last_section.footers.default = Some(id);
+    let l = lay(&d);
+    assert!(l.pages.len() >= 2);
+    let foot_top = extent(&l.pages[0].footer, StoryRef::Part(id)).unwrap().0;
+    assert!(foot_top < 792.0 - 72.0, "the footer is taller than the margin: {foot_top}");
+    for (i, p) in l.pages.iter().enumerate() {
+        let (_, body_bottom) = extent(&p.items, StoryRef::Body).unwrap();
+        let (top, _) = extent(&p.footer, StoryRef::Part(id)).unwrap();
+        assert!(body_bottom <= top + 0.01, "page {i}: body ends at {body_bottom}, footer starts at {top}");
+        assert!(p.body.bottom() <= top + 0.01, "page {i}: {:?}", p.body);
+    }
+    // Every body paragraph is still there, once.
+    let placed: usize = l.pages.iter().flat_map(|p| &p.items).filter(|it| matches!(it, Placed::Lines { story: StoryRef::Body, l0: 0, .. })).count();
+    assert_eq!(placed, d.body.len());
+    // A one-line footer fits in the margin: the body keeps its full height.
+    d.parts.insert(id, wordcraft_doc::Part { kind: PartKind::Footer, blocks: paras("Footer", 1), body: Default::default() });
+    let l = lay(&d);
+    assert!((l.pages[0].body.bottom() - (792.0 - 72.0)).abs() < 0.01, "{:?}", l.pages[0].body);
+}
+
+#[test]
+fn a_linked_tall_header_pushes_the_next_sections_body_down() {
+    // #454: section 2 has no header of its own and shows section 1's (link to previous).
+    let mut d = Document::from_text("First section\nSecond section");
+    let id = d.add_part(PartKind::Header, paras("Header line", 8));
+    let first = SectionProps { headers: wordcraft_doc::section::HeaderSet { default: Some(id), ..Default::default() }, ..d.last_section.clone() };
+    d.para_mut(StoryRef::Body, &Path::top(0)).unwrap().section = Some(Box::new(first));
+    let l = lay(&d);
+    assert_eq!(l.pages.len(), 2);
+    for (i, p) in l.pages.iter().enumerate() {
+        assert_eq!(p.header_story, Some(id), "page {i}");
+        let (_, header_bottom) = extent(&p.header, StoryRef::Part(id)).unwrap();
+        assert!(header_bottom > 72.0, "the header reaches past the top margin");
+        let (body_top, _) = extent(&p.items, StoryRef::Body).unwrap();
+        assert!(body_top >= header_bottom - 0.01, "page {i}: body at {body_top}, header ends at {header_bottom}");
+    }
+    assert_eq!(l.pages[0].body.y, l.pages[1].body.y, "same header, same body top");
+}
+
+#[test]
+fn long_endnotes_continue_on_new_pages() {
+    // #456: an 80-paragraph endnote after a one-line body.
+    let mut d = Document::from_text("Body");
+    let id = d.add_part(PartKind::Endnote, paras("Endnote paragraph", 80));
+    d.insert_object(&Pos::body(0, 4), InlineObject::NoteRef { kind: NoteKind::Endnote, id, custom: String::new() }, &Default::default()).unwrap();
+    let l = lay(&d);
+    assert!(l.pages.len() >= 2, "{} pages", l.pages.len());
+    let mut seen = Vec::new();
+    for (i, p) in l.pages.iter().enumerate() {
+        if let Some((top, bottom)) = extent(&p.items, StoryRef::Part(id)) {
+            assert!(top >= p.body.y - 0.01 && bottom <= p.body.bottom() + 0.01, "page {i}: note at {top}..{bottom}, body {:?}", p.body);
+        }
+        for it in &p.items {
+            if let Placed::Lines { story: StoryRef::Part(s), path, l0: 0, .. } = it
+                && *s == id
+            {
+                seen.push(path.0.clone());
+            }
+        }
+    }
+    assert_eq!(seen, (0..80u32).map(|i| vec![i]).collect::<Vec<_>>(), "every paragraph once, in order");
+    // The caret reaches the last paragraph, on a page.
+    let c = l.caret(&Pos { story: StoryRef::Part(id), path: Path::top(79), off: 0 }).unwrap();
+    assert!(c.top < 792.0 - 72.0, "{c:?}");
+}
+
+#[test]
+fn caret_in_a_continued_footnote_is_found_on_its_page() {
+    // #457: one long footnote paragraph split over pages 1 and 2.
+    let mut d = Document::from_text(&"Body text line.\n".repeat(16));
+    let id = d.add_part(
+        PartKind::Footnote,
+        vec![para_block(Paragraph::with_text(&"A long footnote that runs on and on. ".repeat(100), Default::default()))],
+    );
+    d.insert_object(&Pos::body(4, 4), InlineObject::NoteRef { kind: NoteKind::Footnote, id, custom: String::new() }, &Default::default()).unwrap();
+    let l = lay(&d);
+    // The first line of the piece on page 2.
+    let (para, k) = l.pages[1]
+        .items
+        .iter()
+        .find_map(|it| match it {
+            Placed::Lines { story: StoryRef::Part(s), para, l0, .. } if *s == id && *l0 > 0 => Some((para.clone(), *l0)),
+            _ => None,
+        })
+        .expect("the note continues on page 2");
+    let at = |off: usize| Pos { story: StoryRef::Part(id), path: Path::top(0), off };
+    let cont = at(para.lines[k + 1].start);
+    for hint in [0, 1] {
+        assert_eq!(l.caret_on(&at(0), hint).map(|c| c.page), Some(0), "start, hint {hint}");
+        let c = l.caret_on(&cont, hint).unwrap_or_else(|| panic!("no caret with hint {hint}"));
+        assert_eq!(c.page, 1, "hint {hint}");
+        // Up goes to the line above, not to the note's start.
+        let (up, _) = l.vertical(&cont, None, -1, hint).unwrap();
+        assert_eq!(para.line_of(up.off), k, "hint {hint}: {up:?}");
+    }
+}
diff --git a/crates/layout/src/tests_textbox.rs b/crates/layout/src/tests_textbox.rs
index 80dc012af0..34c82633ee 100644
--- a/crates/layout/src/tests_textbox.rs
+++ b/crates/layout/src/tests_textbox.rs
@@ -26,6 +26,7 @@ fn text_box(d: &mut Document, para: usize, text: &str, w: f32, h: f32, body: Tex
         story: Some(id),
         effects: Default::default(),
         freeform: None,
+        extra: Default::default(),
     };
     let off = d.para(StoryRef::Body, &Path::top(para)).map_or(0, |p| p.len());
     d.insert_object(&Pos::body(para, off), shape, &Default::default()).unwrap();
diff --git a/crates/layout/src/tests_vertical.rs b/crates/layout/src/tests_vertical.rs
new file mode 100644
index 0000000000..aaec1c9ef5
--- /dev/null
+++ b/crates/layout/src/tests_vertical.rs
@@ -0,0 +1,120 @@
+//! Vertical sections (`w:textDirection` in `w:sectPr`): lines run down the page and stack from
+//! the right (`tbRl`), or run up and stack from the left (`btLr`).
+
+use super::*;
+use wordcraft_doc::Pos;
+
+fn lay(doc: &Document) -> DocLayout {
+    let mut c = LayoutCache::new();
+    layout(doc, &mut c, &LayoutOptions::default())
+}
+
+fn vertical_doc(dir: TextDirection) -> Document {
+    let text = "Vertical sections lay their lines out down the page, one after another from right to left. ".repeat(4);
+    let mut d = Document::from_text(&format!("{text}\n日本語のテキスト"));
+    d.last_section.text_direction = dir;
+    d
+}
+
+/// Body lines on page 0: (x, y, turn) of each piece.
+fn body_lines(l: &DocLayout) -> Vec<(f32, f32, TextDirection)> {
+    l.pages[0]
+        .items
+        .iter()
+        .filter_map(|it| match it {
+            Placed::Lines { story: StoryRef::Body, x, y, turn, .. } => Some((*x, *y, *turn)),
+            _ => None,
+        })
+        .collect()
+}
+
+#[test]
+fn top_to_bottom_section_stacks_lines_from_the_right() {
+    let d = vertical_doc(TextDirection::Down);
+    let l = lay(&d);
+    let page = &l.pages[0];
+    // The page keeps its size; the text area is the real one (inside the margins).
+    assert_eq!((page.w, page.h), (d.last_section.page_w, d.last_section.page_h));
+    assert!(page.body.x >= d.last_section.margin_left - 0.5 && page.body.right() <= page.w - d.last_section.margin_right + 0.5);
+    let lines = body_lines(&l);
+    assert!(lines.len() >= 2);
+    assert!(lines.iter().all(|(.., t)| *t == TextDirection::Down));
+    // The first paragraph's first line is the rightmost, the next paragraph left of it.
+    let p0 = Pos::body(0, 0);
+    let c0 = l.caret(&p0).unwrap();
+    let c1 = l.caret(&Pos::body(1, 0)).unwrap();
+    assert!(c1.x < c0.x, "second paragraph left of the first: {c1:?} vs {c0:?}");
+    assert!(c0.x <= page.body.right() + 0.5 && c0.top >= page.body.y - 0.5);
+    // Characters progress downward along a line; the caret lies across it.
+    let c5 = l.caret(&Pos::body(0, 2)).unwrap();
+    assert!(c5.top > c0.top && (c5.x - c0.x).abs() < 0.5, "{c5:?} vs {c0:?}");
+    assert!(c0.width > c0.height);
+    // Line two of the first paragraph is left of line one.
+    let p = d.para(StoryRef::Body, &Path::top(0)).unwrap();
+    let wrap = l.index.get(&(StoryRef::Body, Path::top(0))).map(|v| v[0]).unwrap();
+    let Placed::Lines { para, .. } = &l.pages[wrap.0].items[wrap.1] else { panic!() };
+    assert!(para.lines.len() >= 2 && para.lines[1].start < p.len());
+    let c_next = l.caret(&Pos::body(0, para.lines[1].start + 1)).unwrap();
+    assert!(c_next.x < c0.x - 1.0);
+    // Clicking a caret position finds it again.
+    for off in [0, 2, para.lines[1].start + 1] {
+        let c = l.caret(&Pos::body(0, off)).unwrap();
+        let hit = l.hit(c.page, c.x + c.width / 2.0, c.top + 0.2, StoryRef::Body).unwrap();
+        assert_eq!(hit.off, off);
+    }
+    // Clicking in the empty space below a short line lands on that line (its end).
+    let c_cjk = l.caret(&Pos::body(1, 0)).unwrap();
+    let below = l.hit(0, c_cjk.x + c_cjk.width / 2.0, page.body.bottom() - 2.0, StoryRef::Body).unwrap();
+    assert_eq!(below.path, Path::top(1));
+}
+
+#[test]
+fn bottom_to_top_section_stacks_lines_from_the_left() {
+    let l = lay(&vertical_doc(TextDirection::Up));
+    assert!(body_lines(&l).iter().all(|(.., t)| *t == TextDirection::Up));
+    let c0 = l.caret(&Pos::body(0, 0)).unwrap();
+    let c1 = l.caret(&Pos::body(1, 0)).unwrap();
+    let c5 = l.caret(&Pos::body(0, 2)).unwrap();
+    assert!(c1.x > c0.x, "second paragraph right of the first");
+    assert!(c5.top < c0.top, "characters progress upward");
+}
+
+#[test]
+fn east_asian_characters_stand_upright_in_top_to_bottom_text() {
+    let l = lay(&vertical_doc(TextDirection::Down));
+    let d = vertical_doc(TextDirection::Down);
+    let draws = display::page_display(&d, &l.pages[0], &Default::default());
+    let turned: Vec<&Vec<display::Draw>> =
+        draws.iter().filter_map(|x| if let display::Draw::Turned { items, .. } = x { Some(items) } else { None }).collect();
+    let text_of = |ds: &[display::Draw]| -> String {
+        ds.iter()
+            .map(|x| match x {
+                display::Draw::Glyphs { text, .. } => text.clone(),
+                display::Draw::Rotated { items, .. } => {
+                    items.iter().map(|i| if let display::Draw::Glyphs { text, .. } = i { text.clone() } else { String::new() }).collect()
+                }
+                _ => String::new(),
+            })
+            .collect()
+    };
+    // Each ideograph turned back upright on its own; the Latin text lies with the line.
+    let cjk = turned.iter().find(|ds| text_of(ds).contains('日')).expect("the Japanese line is drawn turned");
+    let upright = cjk.iter().filter(|x| matches!(x, display::Draw::Rotated { spin, .. } if spin.deg == 270.0)).count();
+    assert_eq!(upright, "日本語のテキスト".chars().count());
+    assert!(turned.iter().any(|ds| text_of(ds).contains("Vertical") && ds.iter().all(|x| !matches!(x, display::Draw::Rotated { .. }))));
+}
+
+#[test]
+fn headers_stay_horizontal_and_a_vertical_section_starts_a_page() {
+    use wordcraft_doc::section::SectionStart;
+    let mut d = Document::from_text("Horizontal\nVertical");
+    // Section 1 ends after paragraph 0 (continuous), section 2 is vertical.
+    let first = SectionProps { start: SectionStart::Continuous, ..Default::default() };
+    d.para_mut(StoryRef::Body, &Path::top(0)).unwrap().section = Some(Box::new(first));
+    d.last_section.start = SectionStart::Continuous;
+    d.last_section.text_direction = TextDirection::Down;
+    let l = lay(&d);
+    assert_eq!(l.pages.len(), 2);
+    assert_eq!(l.caret(&Pos::body(0, 0)).unwrap().width, 0.0);
+    assert!(l.caret(&Pos::body(1, 0)).unwrap().width > 0.0);
+}
diff --git a/crates/layout/src/vertical.rs b/crates/layout/src/vertical.rs
new file mode 100644
index 0000000000..cbd0b138c8
--- /dev/null
+++ b/crates/layout/src/vertical.rs
@@ -0,0 +1,123 @@
+//! Vertical sections (Layout › Text Direction, `w:textDirection` in `w:sectPr`).
+//!
+//! A vertical section is laid out unturned on a page turned onto its side — lines as long as the
+//! page's text area is tall, stacking across its width — and each finished page is then turned
+//! onto the real page, as a table cell's turned text is: top-to-bottom lines stack from the right
+//! (`tbRl`), bottom-to-top ones from the left (`btLr`). Pictures, shapes and text boxes keep
+//! standing upright where the turn carries them; headers and footers stay horizontal.
+
+use wordcraft_doc::StoryRef;
+use wordcraft_doc::props::{Borders, TextDirection};
+use wordcraft_doc::section::SectionProps;
+use wordcraft_geom::{Point, Rect};
+
+use crate::{Page, Placed, turn_point, turn_rect};
+
+/// The page a section running `turn` is laid out on, unturned: the real page `s` on its side,
+/// its margins turned with it. `body_top` is where the real page's body starts (below a tall
+/// header). Columns divide the turned page's width, so they stack down the real page.
+pub(crate) fn unturned_sect(s: &SectionProps, body_top: f32) -> SectionProps {
+    let mut v = s.clone();
+    v.page_w = s.page_h;
+    v.page_h = s.page_w;
+    v.gutter = 0.0;
+    let (top, right, bottom, left) = (body_top, s.margin_right, s.margin_bottom, s.margin_left + s.gutter);
+    // The unturned frame's (u, v) lands at (W - v, u) for `Down` and (v, H - u) for `Up`: its
+    // top edge is the real right edge (left for `Up`), its left edge the real top (bottom).
+    match s.text_direction {
+        TextDirection::Horizontal => return v,
+        TextDirection::Down => {
+            (v.margin_top, v.margin_left, v.margin_bottom, v.margin_right) = (right, top, left, bottom);
+            v.page_borders = s.page_borders.as_ref().map(|b| Borders { top: b.right, left: b.top, bottom: b.left, right: b.bottom, ..*b });
+        }
+        TextDirection::Up => {
+            (v.margin_top, v.margin_left, v.margin_bottom, v.margin_right) = (left, bottom, right, top);
+            v.page_borders = s.page_borders.as_ref().map(|b| Borders { top: b.left, left: b.bottom, bottom: b.right, right: b.top, ..*b });
+        }
+    }
+    v
+}
+
+/// Where the unturned frame's origin lands on the real `w` × `h` page.
+fn origin(turn: TextDirection, w: f32, h: f32) -> (f32, f32) {
+    match turn {
+        TextDirection::Horizontal => (0.0, 0.0),
+        TextDirection::Down => (w, 0.0),
+        TextDirection::Up => (0.0, h),
+    }
+}
+
+/// Turn a page laid out unturned (see [`unturned_sect`]) onto the real `phys` page.
+pub(crate) fn turn_page(page: &mut Page, turn: TextDirection, phys: &SectionProps) {
+    if !turn.is_turned() {
+        return;
+    }
+    let (ox, oy) = origin(turn, phys.page_w, phys.page_h);
+    page.w = phys.page_w;
+    page.h = phys.page_h;
+    page.body = turn_rect(turn, ox, oy, page.body);
+    // Pictures, shapes and text boxes stand upright: their centres move with the turn. A text
+    // box's text moves with its box (it runs as the box says, not as the page does).
+    let upright = |r: Rect| {
+        let (cx, cy) = turn_point(turn, ox, oy, r.x + r.w / 2.0, r.y + r.h / 2.0);
+        Rect::new(cx - r.w / 2.0, cy - r.h / 2.0, r.w, r.h)
+    };
+    let mut boxes: Vec<(u32, Rect, (f32, f32))> = Vec::new();
+    for it in &mut page.items {
+        if let Placed::Object { rect, origin, text_box, .. } = it {
+            let r = upright(*rect);
+            if let Some(id) = text_box {
+                boxes.push((*id, *rect, (r.x - rect.x, r.y - rect.y)));
+            }
+            *rect = r;
+            (origin.x, origin.y) = turn_point(turn, ox, oy, origin.x, origin.y);
+        }
+    }
+    let in_box = |it: &Placed| -> Option<(f32, f32)> {
+        if let Placed::Lines { story: StoryRef::Part(id), .. } = it
+            && let Some((_, _, d)) = boxes.iter().find(|(b, _, _)| b == id)
+        {
+            return Some(*d);
+        }
+        let r = bounds(it)?;
+        boxes
+            .iter()
+            .find(|(_, b, _)| b.expand(0.5).contains(Point::new(r.x, r.y)) && b.expand(0.5).contains(Point::new(r.right(), r.bottom())))
+            .map(|(_, _, d)| *d)
+    };
+    for it in &mut page.items {
+        if matches!(it, Placed::Object { .. }) {
+            continue;
+        }
+        if let Some((dx, dy)) = in_box(it) {
+            it.translate(dx, dy);
+            continue;
+        }
+        match it {
+            Placed::Image { rect, .. } | Placed::Shape { rect, .. } | Placed::Graphic { rect, .. } => *rect = upright(*rect),
+            _ => it.turn(turn, ox, oy),
+        }
+    }
+}
+
+/// An item's unturned page area (lines: their band; `None` for turned lines, which a text box
+/// in the section holds).
+fn bounds(it: &Placed) -> Option<Rect> {
+    match it {
+        Placed::Lines { para, l0, l1, x, y, turn, .. } if !turn.is_turned() => {
+            let first = para.lines.get(*l0)?;
+            let last = para.lines.get(l1.checked_sub(1)?)?;
+            let right = para.lines.get(*l0..*l1).unwrap_or(&[]).iter().map(|l| l.right).fold(0.0f32, f32::max);
+            Some(Rect::new(*x, *y, right, last.top + last.height - first.top))
+        }
+        Placed::Lines { .. } => it.turned_bounds(),
+        Placed::Fill { rect, .. }
+        | Placed::Image { rect, .. }
+        | Placed::Shape { rect, .. }
+        | Placed::Graphic { rect, .. }
+        | Placed::Clip { rect, .. }
+        | Placed::Cell { rect, .. }
+        | Placed::Object { rect, .. } => Some(*rect),
+        Placed::Rule { x0, y0, x1, y1, .. } => Some(Rect::new(x0.min(*x1), y0.min(*y1), (x1 - x0).abs(), (y1 - y0).abs())),
+    }
+}
diff --git a/crates/layout/src/wordart.rs b/crates/layout/src/wordart.rs
new file mode 100644
index 0000000000..0938b9b7fa
--- /dev/null
+++ b/crates/layout/src/wordart.rs
@@ -0,0 +1,335 @@
+//! WordArt drawing: text effects as paint layers, and text warps.
+//!
+//! Text with effects is drawn from its glyph outlines ([`glyph_path`]) as a [`Draw::Art`]
+//! (crate::display::Draw::Art), which [`art_layers`] turns into plain fills and strokes for the
+//! raster and PDF back ends: reflection, shadow, glow, fill, outline, in that order. A warped
+//! text box's outlines are bent by [`Warp`] before that. Blurs are approximated with
+//! [`wordcraft_doc::effects::bands`], as for shapes.
+
+use kurbo::{Affine, BezPath, PathEl, Point, Shape};
+use wordcraft_doc::props::Rgb;
+use wordcraft_doc::wordart::{TextEffects, TextFill, TextWarp};
+use wordcraft_fonts::FaceRef;
+use wordcraft_geom::Rect;
+
+/// How a layer is painted.
+#[derive(Clone, Debug, PartialEq)]
+pub enum ArtPaint {
+    Solid(Rgb, f32),
+    /// A linear gradient from `p0` to `p1` (page points); stops are (offset 0..1, colour, opacity).
+    Linear {
+        p0: (f32, f32),
+        p1: (f32, f32),
+        stops: Vec<(f32, Rgb, f32)>,
+    },
+}
+
+/// One fill (`stroke: None`) or stroke (its width, points) of a path.
+#[derive(Clone, Debug)]
+pub struct ArtLayer {
+    pub path: BezPath,
+    pub paint: ArtPaint,
+    pub stroke: Option<f32>,
+}
+
+/// The outlines of `glyphs` (glyph id, pen x, baseline y in page points) of `face` at `size`, as
+/// one path in page coordinates (slanted for synthetic italics).
+pub fn glyph_path(face: &FaceRef, size: f32, glyphs: &[(u32, f32, f32)], synth_italic: bool) -> BezPath {
+    let db = wordcraft_fonts::FontDb::global();
+    let k = f64::from(size) / face.upem.max(1.0);
+    let skew = if synth_italic { Affine::new([1.0, 0.0, -0.21, 1.0, 0.0, 0.0]) } else { Affine::IDENTITY };
+    let mut out = BezPath::new();
+    for &(gid, x, y) in glyphs {
+        if !(x.is_finite() && y.is_finite()) {
+            continue;
+        }
+        let m = Affine::translate((f64::from(x), f64::from(y))) * skew * Affine::scale(k);
+        for el in db.outline(face, gid).elements() {
+            out.push(m * *el);
+        }
+    }
+    out
+}
+
+fn bbox(path: &BezPath) -> Option<kurbo::Rect> {
+    if path.elements().is_empty() {
+        return None;
+    }
+    let b = path.bounding_box();
+    (b.x0.is_finite() && b.y0.is_finite() && b.x1.is_finite() && b.y1.is_finite()).then_some(b)
+}
+
+/// The layers that draw `path` (text outlines, page coordinates) with effects `fx` (sanitized
+/// here); `color` is the run's own colour (the fill when `fx` sets none), `alpha` an overall
+/// opacity.
+pub fn art_layers(path: &BezPath, fx: &TextEffects, color: Rgb, alpha: f32) -> Vec<ArtLayer> {
+    let fx = fx.sanitized();
+    let alpha = if alpha.is_finite() { alpha.clamp(0.0, 1.0) } else { 1.0 };
+    let Some(b) = bbox(path) else { return Vec::new() };
+    let mut out = Vec::new();
+    let fill = fx.fill.clone().unwrap_or(TextFill::Solid { color, transparency: 0.0 });
+    let fill_paint = |path: &BezPath| -> Option<ArtPaint> {
+        match &fill {
+            TextFill::None => None,
+            TextFill::Solid { color, transparency } => Some(ArtPaint::Solid(*color, alpha * (1.0 - transparency / 100.0))),
+            TextFill::Gradient { stops, angle } => {
+                let b = bbox(path)?;
+                let (s, c) = (f64::from(*angle).to_radians().sin(), f64::from(*angle).to_radians().cos());
+                let d = (b.width() * c.abs() + b.height() * s.abs()) / 2.0;
+                let ctr = b.center();
+                let p0 = ((ctr.x - d * c) as f32, (ctr.y - d * s) as f32);
+                let p1 = ((ctr.x + d * c) as f32, (ctr.y + d * s) as f32);
+                Some(ArtPaint::Linear {
+                    p0,
+                    p1,
+                    stops: stops.iter().map(|g| (g.pos / 100.0, g.color, alpha * (1.0 - g.transparency / 100.0))).collect(),
+                })
+            }
+        }
+    };
+    let outline = fx.outline.and_then(|o| o.color.map(|c| (c, o.width.max(0.25), alpha * (1.0 - o.transparency / 100.0))));
+    // A colour standing for the letters (shadows and reflections of hollow text use the outline's).
+    let ink = fill.main_color().or(outline.map(|o| o.0)).unwrap_or(color);
+    if let Some(r) = fx.reflection {
+        // Mirrored about the letters' bottom edge, `distance` below it, fading out downwards.
+        let gap = f64::from(r.distance);
+        let m = Affine::new([1.0, 0.0, 0.0, -1.0, 0.0, 2.0 * b.y1 + gap]);
+        let mirror = m * path.clone();
+        let top = (b.y1 + gap) as f32;
+        let bottom = top + (b.height() as f32) * (r.size / 100.0).max(0.01);
+        let x = b.x0 as f32;
+        let a = alpha * (1.0 - r.transparency / 100.0);
+        out.push(ArtLayer {
+            path: mirror,
+            paint: ArtPaint::Linear { p0: (x, top), p1: (x, bottom), stops: vec![(0.0, ink, a), (1.0, ink, 0.0)] },
+            stroke: None,
+        });
+    }
+    if let Some(sh) = fx.shadow {
+        let (dx, dy) = sh.offset();
+        let moved = Affine::translate((f64::from(dx), f64::from(dy))) * path.clone();
+        for (g, a) in wordcraft_doc::effects::bands(0.0, sh.blur / 2.0, sh.opacity() * alpha) {
+            let paint = ArtPaint::Solid(sh.color, a);
+            out.push(ArtLayer { path: moved.clone(), paint: paint.clone(), stroke: None });
+            if g > 0.05 {
+                out.push(ArtLayer { path: moved.clone(), paint, stroke: Some(2.0 * g) });
+            }
+        }
+    }
+    if let Some(gl) = fx.glow {
+        for (g, a) in wordcraft_doc::effects::bands(0.0, gl.size, gl.opacity() * alpha) {
+            if g > 0.05 {
+                out.push(ArtLayer { path: path.clone(), paint: ArtPaint::Solid(gl.color, a), stroke: Some(2.0 * g) });
+            }
+        }
+    }
+    if let Some(p) = fill_paint(path) {
+        out.push(ArtLayer { path: path.clone(), paint: p, stroke: None });
+    }
+    if let Some((c, w, a)) = outline {
+        out.push(ArtLayer { path: path.clone(), paint: ArtPaint::Solid(c, a), stroke: Some(w) });
+    }
+    out
+}
+
+/// How a warp bends text: two edges (top and bottom, the text stretched between them), or an arc
+/// (the text running along an ellipse, its letters standing out or in).
+#[derive(Clone, Copy, Debug)]
+enum Bend {
+    /// The top and bottom edges' heights (fractions of the frame, 0 = top) at `u` across.
+    Edges(fn(f32, f32) -> (f32, f32)),
+    /// Along an ellipse from angle `start` (radians, counter-clockwise from the right, y up)
+    /// sweeping `sweep` (negative: clockwise); `outward`: the letters' tops point away from the
+    /// centre.
+    Arc { start: f32, sweep: f32, outward: bool },
+}
+
+/// A warp fitted to a frame: maps the text's box (`u`, `v` in 0..1, `v` = 0 at the top) onto the
+/// frame.
+#[derive(Clone, Copy, Debug)]
+pub struct Warp {
+    frame: Rect,
+    bend: Bend,
+    /// How far the edges bend (a fraction of the frame's height).
+    k: f32,
+    /// The text's thickness along an arc, as a fraction of the radius.
+    thick: f32,
+}
+
+fn slant_up(u: f32, k: f32) -> (f32, f32) {
+    (k * (1.0 - u), 1.0 - k * u)
+}
+fn slant_down(u: f32, k: f32) -> (f32, f32) {
+    (k * u, 1.0 - k * (1.0 - u))
+}
+fn inflate(u: f32, k: f32) -> (f32, f32) {
+    let s = (std::f32::consts::PI * u).sin();
+    (k * (1.0 - s), 1.0 - k * (1.0 - s))
+}
+fn deflate(u: f32, k: f32) -> (f32, f32) {
+    let s = (std::f32::consts::PI * u).sin();
+    (k * s, 1.0 - k * s)
+}
+fn wave(u: f32, k: f32) -> (f32, f32) {
+    let d = k * (2.0 * std::f32::consts::PI * u).sin();
+    (k - d, 1.0 - k - d)
+}
+fn chevron_up(u: f32, k: f32) -> (f32, f32) {
+    let t = (2.0 * u - 1.0).abs();
+    (k * t, 1.0 - k * (1.0 - t))
+}
+fn chevron_down(u: f32, k: f32) -> (f32, f32) {
+    let t = (2.0 * u - 1.0).abs();
+    (k * (1.0 - t), 1.0 - k * t)
+}
+fn triangle_up(u: f32, k: f32) -> (f32, f32) {
+    (k * (2.0 * u - 1.0).abs(), 1.0)
+}
+fn triangle_down(u: f32, k: f32) -> (f32, f32) {
+    (0.0, 1.0 - k * (2.0 * u - 1.0).abs())
+}
+
+impl Warp {
+    /// The warp `w` fitted to `frame` for text whose box is `aspect` times as tall as it is
+    /// wide. `None` for warps drawn flat (plain, and those WordCraft doesn't bend).
+    pub fn new(w: &TextWarp, frame: Rect, aspect: f32) -> Option<Warp> {
+        use std::f32::consts::PI;
+        if !(frame.w > 0.5 && frame.h > 0.5 && frame.w.is_finite() && frame.h.is_finite()) {
+            return None;
+        }
+        // `adj` as a fraction (100000ths) of the frame's height, within `max`, else `dflt`.
+        let frac = |dflt: f32, max: f32| w.adj_value("adj").map_or(dflt, |v| (v as f32 / 100_000.0).clamp(0.0, max));
+        // `adj` as the angle the arc sweeps (60000ths of a degree), else a half turn.
+        let sweep = w.adj_value("adj").map_or(PI, |v| (v as f32 / 60_000.0).clamp(10.0, 350.0).to_radians());
+        let edges = |f: fn(f32, f32) -> (f32, f32), k: f32| (Bend::Edges(f), k);
+        let (bend, k) = match w.preset.as_str() {
+            "textSlantUp" => edges(slant_up, frac(0.4, 0.9)),
+            "textSlantDown" => edges(slant_down, frac(0.4, 0.9)),
+            "textInflate" => edges(inflate, frac(0.3, 0.45)),
+            "textDeflate" => edges(deflate, frac(0.3, 0.45)),
+            "textWave1" => edges(wave, frac(0.125, 0.3)),
+            "textChevron" => edges(chevron_up, frac(0.4, 0.9)),
+            "textChevronInverted" => edges(chevron_down, frac(0.4, 0.9)),
+            "textTriangle" => edges(triangle_up, frac(0.5, 0.9)),
+            "textTriangleInverted" => edges(triangle_down, frac(0.5, 0.9)),
+            "textArchUp" => (Bend::Arc { start: PI / 2.0 + sweep / 2.0, sweep: -sweep, outward: true }, 0.0),
+            "textArchDown" => (Bend::Arc { start: 1.5 * PI - sweep / 2.0, sweep, outward: false }, 0.0),
+            "textCircle" => (Bend::Arc { start: 1.5 * PI - 0.02, sweep: -(2.0 * PI - 0.04), outward: true }, 0.0),
+            _ => return None,
+        };
+        // Along an arc the text keeps its proportions: as thick as its length along the mean
+        // radius makes it, within reason.
+        let thick = match bend {
+            Bend::Arc { sweep, .. } => {
+                let aspect = if aspect.is_finite() { aspect.clamp(0.0, 10.0) } else { 0.2 };
+                (aspect * sweep.abs()).clamp(0.08, 0.6)
+            }
+            Bend::Edges(_) => 0.0,
+        };
+        Some(Warp { frame, bend, k, thick })
+    }
+
+    /// The page point for text box point (`u`, `v`).
+    pub fn map(&self, u: f32, v: f32) -> (f32, f32) {
+        let (u, v) = (if u.is_finite() { u } else { 0.0 }, if v.is_finite() { v } else { 0.0 });
+        let f = self.frame;
+        match self.bend {
+            Bend::Edges(edge) => {
+                let (top, bottom) = edge(u.clamp(-1.0, 2.0), self.k);
+                (f.x + u * f.w, f.y + (top + (bottom - top) * v) * f.h)
+            }
+            Bend::Arc { start, sweep, outward } => {
+                let (rx, ry) = (f.w / 2.0, f.h / 2.0);
+                let (cx, cy) = (f.x + rx, f.y + ry);
+                let a = start + sweep * u;
+                let rho = if outward { 1.0 - v * self.thick } else { 1.0 - self.thick + v * self.thick };
+                (cx + rx * rho * a.cos(), cy - ry * rho * a.sin())
+            }
+        }
+    }
+}
+
+/// `path` bent by `warp`, its box `src` mapped onto the warp's frame. Curves are flattened and
+/// long lines cut short so they bend smoothly.
+pub fn warp_path(path: &BezPath, src: kurbo::Rect, warp: &Warp) -> BezPath {
+    let (w, h) = (src.width().max(1e-3), src.height().max(1e-3));
+    let step = (w / 96.0).max(0.25);
+    let to = |p: Point| {
+        let (x, y) = warp.map(((p.x - src.x0) / w) as f32, ((p.y - src.y0) / h) as f32);
+        Point::new(f64::from(x), f64::from(y))
+    };
+    let mut out = BezPath::new();
+    let mut last: Option<Point> = None;
+    // Bounded: a hostile path can't make it endless (each line cut in at most 256 pieces).
+    kurbo::flatten(path.elements().iter().copied(), 0.05, |el| match el {
+        PathEl::MoveTo(p) => {
+            out.move_to(to(p));
+            last = Some(p);
+        }
+        PathEl::LineTo(p) => {
+            if let Some(a) = last {
+                let n = ((a.distance(p) / step).ceil() as usize).clamp(1, 256);
+                for i in 1..=n {
+                    out.line_to(to(a.lerp(p, i as f64 / n as f64)));
+                }
+            } else {
+                out.move_to(to(p));
+            }
+            last = Some(p);
+        }
+        PathEl::ClosePath => out.close_path(),
+        _ => {}
+    });
+    out
+}
+
+/// The box of `path`, if it has one.
+pub fn path_box(path: &BezPath) -> Option<kurbo::Rect> {
+    bbox(path)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn arch_baselines_lie_on_the_arc() {
+        let frame = Rect::new(10.0, 20.0, 200.0, 100.0);
+        let w = Warp::new(&TextWarp::new("textArchUp").unwrap(), frame, 0.25).unwrap();
+        let (cx, cy, rx, ry) = (110.0, 70.0, 100.0, 50.0);
+        // A baseline (fixed v) maps onto one ellipse around the frame's centre, over the top.
+        for v in [0.0, 0.8] {
+            let rho: Vec<f32> = (0..=10)
+                .map(|i| {
+                    let (x, y) = w.map(i as f32 / 10.0, v);
+                    assert!(y <= cy + 1e-3, "over the top: {y}");
+                    (((x - cx) / rx).powi(2) + ((y - cy) / ry).powi(2)).sqrt()
+                })
+                .collect();
+            assert!(rho.iter().all(|r| (r - rho[0]).abs() < 1e-3), "{rho:?}");
+        }
+        // Left to right, the middle at the top.
+        let (x0, _) = w.map(0.0, 0.0);
+        let (xm, ym) = w.map(0.5, 0.0);
+        let (x1, _) = w.map(1.0, 0.0);
+        assert!(x0 < xm && xm < x1 && (ym - 20.0).abs() < 1e-3);
+        // Arch down runs along the bottom.
+        let d = Warp::new(&TextWarp::new("textArchDown").unwrap(), frame, 0.25).unwrap();
+        assert!(d.map(0.5, 1.0).1 > 119.0);
+    }
+
+    #[test]
+    fn flat_and_unknown_warps_draw_flat() {
+        let frame = Rect::new(0.0, 0.0, 100.0, 50.0);
+        assert!(Warp::new(&TextWarp::new("textPlain").unwrap(), frame, 0.2).is_none());
+        assert!(Warp::new(&TextWarp::new("textCanUp").unwrap(), frame, 0.2).is_none());
+        // Hostile adjust values stay within the frame.
+        let mut t = TextWarp::new("textSlantUp").unwrap();
+        t.set_adj("adj", i64::MAX);
+        let w = Warp::new(&t, frame, f32::NAN).unwrap();
+        for (u, v) in [(0.0, 0.0), (1.0, 1.0), (f32::NAN, 0.5)] {
+            let (x, y) = w.map(u, v);
+            assert!((0.0..=100.0).contains(&x) && (0.0..=50.0).contains(&y), "{x} {y}");
+        }
+    }
+}
diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rs
index 52756749c9..6a3310703a 100644
--- a/crates/mcp/src/tests.rs
+++ b/crates/mcp/src/tests.rs
@@ -67,3 +67,43 @@ fn resources() {
     let r = call(&mut s, 2, "resources/read", json!({"uri": "wordcraft://document"}));
     assert!(r["result"]["contents"][0]["text"].as_str().unwrap().contains("blocks"));
 }
+
+/// A backend standing in for a running app: it answers `ui.render` and `ui.screenshot` with a
+/// PNG in the reply and records what it was asked.
+struct FakeApp {
+    calls: std::sync::Arc<std::sync::Mutex<Vec<(String, Value)>>>,
+}
+
+impl crate::backend::Backend for FakeApp {
+    fn call(&mut self, method: &str, params: Value) -> Result<Value, String> {
+        self.calls.lock().unwrap().push((method.to_string(), params.clone()));
+        match method {
+            "ui.render" | "ui.screenshot" => Ok(json!({"png": wordcraft_engine::cmd::insert::base64_encode(b"\x89PNG"), "width": 1, "height": 1})),
+            other => Err(format!("unexpected {other}")),
+        }
+    }
+    fn has_ui(&self) -> bool {
+        true
+    }
+    fn describe(&self) -> String {
+        "fake app".into()
+    }
+}
+
+/// With an app attached, pictures travel inside the reply: the bridge never writes a file with a
+/// predictable name into the shared temporary folder (another user could plant a link there).
+#[test]
+fn render_and_screenshot_through_the_app_use_no_temp_file() {
+    let calls = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
+    let mut s = Server::new(Box::new(FakeApp { calls: calls.clone() }));
+    for (tool, method) in [("render_page", "ui.render"), ("screenshot", "ui.screenshot")] {
+        let r = call(&mut s, 10, "tools/call", json!({"name": tool, "arguments": {"page": 1}}));
+        let content = &r["result"]["content"];
+        assert_eq!(r["result"]["isError"], false, "{tool}: {r}");
+        assert_eq!(content[0]["type"], "image", "{tool}");
+        assert_eq!(content[0]["data"], wordcraft_engine::cmd::insert::base64_encode(b"\x89PNG"), "{tool}");
+        let (m, params) = calls.lock().unwrap().pop().expect("one call");
+        assert_eq!(m, method);
+        assert!(params.get("path").is_none(), "{tool} asked for a file: {params}");
+    }
+}
diff --git a/crates/mcp/src/tools.rs b/crates/mcp/src/tools.rs
index ca1961e5ea..b01106af6c 100644
--- a/crates/mcp/src/tools.rs
+++ b/crates/mcp/src/tools.rs
@@ -4,6 +4,14 @@ use serde_json::{Value, json};
 
 use crate::backend::Backend;
 
+/// An image tool result from a reply carrying base64 PNG in `png`.
+fn png_result(v: &Value, info: &Value) -> ToolResult {
+    match v.get("png").and_then(Value::as_str) {
+        Some(png) if !png.is_empty() => ToolResult::image(png.to_string(), info),
+        _ => ToolResult::error("the reply carried no picture"),
+    }
+}
+
 #[derive(Clone, Debug, PartialEq)]
 pub struct ToolResult {
     pub content: Vec<Value>,
@@ -80,7 +88,7 @@ pub fn tool_definitions() -> Value {
         tool(
             "open_document",
             "Open",
-            "Open a .docx, .odt, .rtf, .md, .tex, .html, .txt or .json file.",
+            "Open a .docx, .doc, .odt, .rtf, .md, .tex, .html, .txt or .json file, or any other text file (.m3u, .log, .ini…) as plain text.",
             obj(json!({"path": s("File path")}), &["path"]),
             false
         ),
@@ -244,37 +252,19 @@ pub fn call_tool(b: &mut dyn Backend, name: &str, a: &Value) -> ToolResult {
         "get_text" => wrap(exec(b, "document.text", json!({}))),
         "inspect_document" => wrap(b.call("document.inspect", json!({}))),
         "parity" => wrap(b.call("ui.parity", json!({}))),
+        // Pictures travel inside the reply (`png`), headless or through the app: no file with a
+        // predictable name in the shared temporary folder.
         "render_page" => {
-            if b.has_ui() {
-                let path = std::env::temp_dir().join("wordcraft-mcp-page.png");
-                let path_s = path.to_string_lossy().to_string();
-                match b.call("ui.render", json!({"path": path_s, "page": a.get("page").cloned().unwrap_or(json!(1)), "scale": a.get("scale").cloned().unwrap_or(json!(1.0))})) {
-                    Ok(info) => match std::fs::read(&path) {
-                        Ok(bytes) => ToolResult::image(wordcraft_engine::cmd::insert::base64_encode(&bytes), &info),
-                        Err(e) => ToolResult::error(e.to_string()),
-                    },
-                    Err(e) => ToolResult::error(e),
-                }
-            } else {
-                match b.call("ui.render", a.clone()) {
-                    Ok(v) => {
-                        let png = v.get("png").and_then(Value::as_str).unwrap_or("").to_string();
-                        ToolResult::image(png, &json!({"width": v["width"], "height": v["height"], "pages": v["pages"]}))
-                    }
-                    Err(e) => ToolResult::error(e),
-                }
-            }
-        }
-        "screenshot" => {
-            let path = std::env::temp_dir().join("wordcraft-mcp-shot.png");
-            match b.call("ui.screenshot", json!({"path": path.to_string_lossy()})) {
-                Ok(info) => match std::fs::read(&path) {
-                    Ok(bytes) => ToolResult::image(wordcraft_engine::cmd::insert::base64_encode(&bytes), &info),
-                    Err(e) => ToolResult::error(e.to_string()),
-                },
+            let params = json!({"page": a.get("page").cloned().unwrap_or(json!(1)), "scale": a.get("scale").cloned().unwrap_or(json!(1.0))});
+            match b.call("ui.render", params) {
+                Ok(v) => png_result(&v, &json!({"width": v["width"], "height": v["height"], "pages": v["pages"]})),
                 Err(e) => ToolResult::error(e),
             }
         }
+        "screenshot" => match b.call("ui.screenshot", json!({})) {
+            Ok(v) => png_result(&v, &json!({"width": v["width"], "height": v["height"]})),
+            Err(e) => ToolResult::error(e),
+        },
         "click" => wrap(b.call("ui.click", a.clone())),
         "key" => wrap(b.call("ui.key", a.clone())),
         "ui_inspect" => wrap(b.call("ui.inspect", json!({}))),
diff --git a/crates/metafile/src/canvas.rs b/crates/metafile/src/canvas.rs
index d553c81959..fa8bfdcf9f 100644
--- a/crates/metafile/src/canvas.rs
+++ b/crates/metafile/src/canvas.rs
@@ -8,6 +8,7 @@ use crate::{MAX_BYTES, MAX_ITEMS, MAX_OBJECTS, MAX_PATH_OPS, MAX_STACK};
 
 pub(crate) const MM_TEXT: u32 = 1;
 const MM_ISOTROPIC: u32 = 7;
+const MM_ANISOTROPIC: u32 = 8;
 const STOCK: u32 = 0x8000_0000;
 pub(crate) const PS_NULL: u32 = 5;
 /// Pen style bits; the rest of the style word holds end-cap, join and type flags.
@@ -15,6 +16,8 @@ pub(crate) const PS_STYLE_MASK: u32 = 0x0F;
 const BS_SOLID: u32 = 0;
 pub(crate) const BS_NULL: u32 = 1;
 const WINDING: u32 = 2;
+/// SETROP2 mix mode that leaves the destination alone: outlines and fills draw nothing.
+const R2_NOP: u32 = 11;
 const PATCOPY: u32 = 0x00F0_0021;
 const BLACKNESS: u32 = 0x0000_0042;
 const WHITENESS: u32 = 0x00FF_0062;
@@ -135,6 +138,19 @@ impl Mapping {
         det * (sx.abs() + sy.abs()) / 2.0
     }
 
+    /// True when the window-to-viewport extents set the scale (the isotropic and anisotropic modes).
+    pub fn uses_extents(&self) -> bool {
+        matches!(self.mode, MM_ISOTROPIC | MM_ANISOTROPIC)
+    }
+
+    pub fn window_ext(&self) -> P {
+        self.we
+    }
+
+    pub fn viewport_ext(&self) -> P {
+        self.ve
+    }
+
     /// The window in device units as `[x, y, w, h]` with positive extents, used as the picture frame
     /// of a plain WMF.
     pub fn window_rect(&self) -> [f64; 4] {
@@ -160,6 +176,7 @@ struct Saved {
     pen: Pen,
     brush: Brush,
     even_odd: bool,
+    nop: bool,
 }
 
 pub(crate) struct Canvas {
@@ -167,6 +184,8 @@ pub(crate) struct Canvas {
     pub map: Mapping,
     /// True once SETWINDOWEXT was seen, so a plain WMF has a frame to use.
     pub window_set: bool,
+    /// True once the file set the viewport extent itself (not the player, see [`Canvas::play_into`]).
+    pub viewport_set: bool,
     saved: Vec<Saved>,
     /// Bytes held by the items so far (path ops and pixels), capped at [`MAX_BYTES`].
     used: usize,
@@ -174,6 +193,8 @@ pub(crate) struct Canvas {
     pen: Pen,
     brush: Brush,
     even_odd: bool,
+    /// The mix mode is R2_NOP: shapes draw nothing.
+    nop: bool,
     pos: P,
     in_path: bool,
     path: Vec<Op>,
@@ -186,12 +207,14 @@ impl Canvas {
             items: Vec::new(),
             map: Mapping::identity(),
             window_set: false,
+            viewport_set: false,
             saved: Vec::new(),
             used: 0,
             objects: Vec::new(),
             pen: Pen { style: 0, width: 0.0, color: [0, 0, 0, 255] },
             brush: Brush { style: BS_SOLID, color: [255, 255, 255, 255] },
             even_odd: true,
+            nop: false,
             pos: (0.0, 0.0),
             in_path: false,
             path: Vec::new(),
@@ -232,6 +255,22 @@ impl Canvas {
 
     pub fn set_viewport_ext(&mut self, e: P) {
         self.map.ve = e;
+        self.viewport_set = true;
+    }
+
+    /// Sets up the mapping the way a player does before it plays a WMF into a target: anisotropic,
+    /// `window` (`[x, y, w, h]` in logical units) onto a viewport of `size` at the origin. The file's
+    /// own window records then replace the window; the viewport stays unless the file sets one.
+    /// Without a window (a plain WMF) only the viewport extent is set: the map mode and viewport
+    /// origin stay the file's.
+    pub fn play_into(&mut self, window: Option<[f64; 4]>, size: P) {
+        if let Some([x, y, w, h]) = window {
+            self.map.mode = MM_ANISOTROPIC;
+            self.map.wo = (x, y);
+            self.map.we = (w, h);
+            self.map.vo = (0.0, 0.0);
+        }
+        self.map.ve = size;
     }
 
     pub fn set_map_mode(&mut self, mode: u32) {
@@ -249,6 +288,11 @@ impl Canvas {
         self.even_odd = mode != WINDING;
     }
 
+    /// SETROP2: only R2_NOP changes what is drawn (nothing); the other mix modes draw as copy.
+    pub fn set_rop2(&mut self, mode: u32) {
+        self.nop = mode == R2_NOP;
+    }
+
     /// EMF SETWORLDTRANSFORM (`mode` 4) and MODIFYWORLDTRANSFORM (1 identity, 2 left, 3 right, 4 set).
     /// An unknown mode leaves the world transform as it was.
     pub fn modify_world(&mut self, x: Xform, mode: u32) {
@@ -265,7 +309,7 @@ impl Canvas {
     /// could no longer match the file.
     pub fn save_dc(&mut self) {
         if self.saved.len() < MAX_STACK {
-            self.saved.push(Saved { map: self.map, pen: self.pen, brush: self.brush, even_odd: self.even_odd });
+            self.saved.push(Saved { map: self.map, pen: self.pen, brush: self.brush, even_odd: self.even_odd, nop: self.nop });
         } else {
             self.full = true;
         }
@@ -281,6 +325,7 @@ impl Canvas {
         self.pen = s.pen;
         self.brush = s.brush;
         self.even_odd = s.even_odd;
+        self.nop = s.nop;
     }
 
     /// Stores an object in `slot` (EMF index), or in the first free slot (WMF handle table).
@@ -381,6 +426,9 @@ impl Canvas {
         if self.in_path {
             return self.push_path_ops(dev);
         }
+        if self.nop {
+            return;
+        }
         let fill = if fill { self.fill_color() } else { None };
         let stroke = if stroke { self.stroke_pen() } else { None };
         if (fill.is_none() && stroke.is_none()) || dev.len() < 2 {
@@ -460,6 +508,9 @@ impl Canvas {
     /// FILLPATH, STROKEPATH and STROKEANDFILLPATH: paints the bracketed path and empties it.
     pub fn paint_path(&mut self, fill: bool, stroke: bool) {
         let ops = std::mem::take(&mut self.path);
+        if self.nop {
+            return;
+        }
         let fill = if fill { self.fill_color() } else { None };
         let stroke = if stroke { self.stroke_pen() } else { None };
         if ops.len() < 2 || (fill.is_none() && stroke.is_none()) {
diff --git a/crates/metafile/src/emf.rs b/crates/metafile/src/emf.rs
index 6f32486978..027cfae9f9 100644
--- a/crates/metafile/src/emf.rs
+++ b/crates/metafile/src/emf.rs
@@ -88,6 +88,7 @@ fn record(cv: &mut Canvas, typ: u32, r: Bytes) {
         12 => xy32(r, 8).map(|p| cv.set_viewport_org(p)),
         17 => r.u32(8).map(|m| cv.set_map_mode(m)),
         19 => r.u32(8).map(|m| cv.set_polyfill(m)),
+        20 => r.u32(8).map(|m| cv.set_rop2(m)),
         33 => {
             cv.save_dc();
             Some(())
diff --git a/crates/metafile/src/tests.rs b/crates/metafile/src/tests.rs
index 9fab9bea73..4ee32578ee 100644
--- a/crates/metafile/src/tests.rs
+++ b/crates/metafile/src/tests.rs
@@ -927,3 +927,92 @@ fn take_pixels_returns_only_drawable_bitmaps() {
     assert!(pic(1.0, 2.0).has_size());
     assert!(!pic(0.0, 2.0).has_size() && !pic(f32::NAN, 2.0).has_size() && !pic(1.0, f32::INFINITY).has_size());
 }
+
+/// The rectangle a WMF RECTANGLE record covers, from its path's corners.
+fn rect_extent(item: &Item) -> (f32, f32, f32, f32) {
+    let (segs, ..) = path_segs(item);
+    let pts: Vec<(f32, f32)> = segs
+        .iter()
+        .filter_map(|s| match s {
+            Seg::Move(x, y) | Seg::Line(x, y) => Some((*x, *y)),
+            _ => None,
+        })
+        .collect();
+    let (xs, ys): (Vec<f32>, Vec<f32>) = pts.into_iter().unzip();
+    let lo = |v: &[f32]| v.iter().copied().fold(f32::MAX, f32::min);
+    let hi = |v: &[f32]| v.iter().copied().fold(f32::MIN, f32::max);
+    (lo(&xs), lo(&ys), hi(&xs), hi(&ys))
+}
+
+#[test]
+fn plain_anisotropic_wmf_without_a_viewport_fills_its_window() {
+    // Anisotropic, window 200 x 100, no viewport (a logo strip saved without a placeable header): the
+    // window is the target, not a 1 x 1 viewport that squeezes the picture to a point.
+    let recs = [
+        wrec(0x0103, &h16(8)),
+        wrec(0x020B, &cat(vec![h16(0), h16(0)])),
+        wrec(0x020C, &cat(vec![h16(100), h16(200)])),
+        wrec(0x041B, &cat(vec![h16(100), h16(200), h16(0), h16(0)])),
+    ];
+    let p = parse(&wmf(&recs, None)).unwrap();
+    assert_eq!((p.width, p.height), (200.0, 100.0));
+    let (x0, y0, x1, y1) = rect_extent(&p.items[0]);
+    assert!(close(x0, 0.0) && close(y0, 0.0) && close(x1, 200.0) && close(y1, 100.0), "{x0} {y0} {x1} {y1}");
+}
+
+#[test]
+fn placeable_wmf_window_records_replace_the_bounds() {
+    // The placeable bounds say 1440 square (72 points); the file then draws in a window centred on the
+    // origin, as a coat of arms saved by a drawing program does. The window maps onto the 72-point
+    // target, so the drawing fills it instead of being blown up around the bounds.
+    let recs = [
+        wrec(0x020C, &cat(vec![h16(2000), h16(2000)])),
+        wrec(0x020B, &cat(vec![h16(-1000), h16(-1000)])),
+        wrec(0x041B, &cat(vec![h16(1000), h16(1000), h16(-1000), h16(-1000)])),
+    ];
+    let p = parse(&wmf(&recs, Some([238, 539, 1678, 1979]))).unwrap();
+    assert_eq!((p.width, p.height), (72.0, 72.0));
+    let (x0, y0, x1, y1) = rect_extent(&p.items[0]);
+    assert!(close(x0, 0.0) && close(y0, 0.0) && close(x1, 72.0) && close(y1, 72.0), "{x0} {y0} {x1} {y1}");
+}
+
+#[test]
+fn placeable_wmf_keeps_its_target_when_the_window_changes_shape() {
+    // Bounds 600 x 300 (30 x 15 points), then a portrait window 100 x 200 for a bitmap-sized drawing:
+    // the drawing still fills the target (Word stretches it to the picture's box).
+    let recs = [wrec(0x0103, &h16(8)), wrec(0x020C, &cat(vec![h16(200), h16(100)])), wrec(0x041B, &cat(vec![h16(200), h16(100), h16(0), h16(0)]))];
+    let p = parse(&wmf(&recs, Some([0, 0, 600, 300]))).unwrap();
+    assert_eq!((p.width, p.height), (30.0, 15.0));
+    let (x0, y0, x1, y1) = rect_extent(&p.items[0]);
+    assert!(close(x0, 0.0) && close(y0, 0.0) && close(x1, 30.0) && close(y1, 15.0), "{x0} {y0} {x1} {y1}");
+}
+
+#[test]
+fn rop2_nop_draws_nothing_until_the_mode_changes() {
+    // A coat of arms that first draws its bounding rectangle with the R2_NOP mix mode (no output),
+    // then its shapes with R2_COPYPEN. Restoring a saved state brings R2_NOP back.
+    let rect = |n: i32| wrec(0x041B, &cat(vec![h16(n), h16(n), h16(0), h16(0)]));
+    let recs = [wrec(0x0104, &h16(11)), rect(100), wrec(0x001E, &[]), wrec(0x0104, &h16(13)), rect(50), wrec(0x0127, &h16(-1)), rect(20)];
+    let p = parse(&wmf(&recs, Some([0, 0, 100, 100]))).unwrap();
+    assert_eq!(p.items.len(), 1, "{:?}", p.items);
+    let (_, _, x1, y1) = rect_extent(&p.items[0]);
+    // 50 of 100 units in a 5-point picture.
+    assert!(close(x1, 2.5) && close(y1, 2.5), "{x1} {y1}");
+}
+
+#[test]
+fn plain_wmf_target_comes_from_a_window_that_was_read() {
+    // A window record too short to read, then the real one: the target is the real window, not the
+    // 1 x 1 default the short record left in place. A viewport origin set before it is kept.
+    let recs = [
+        wrec(0x0103, &h16(8)),
+        wrec(0x020D, &cat(vec![h16(0), h16(0)])),
+        wrec(0x020C, &[]),
+        wrec(0x020C, &cat(vec![h16(100), h16(200)])),
+        wrec(0x041B, &cat(vec![h16(100), h16(200), h16(0), h16(0)])),
+    ];
+    let p = parse(&wmf(&recs, None)).unwrap();
+    assert_eq!((p.width, p.height), (200.0, 100.0));
+    let (x0, y0, x1, y1) = rect_extent(&p.items[0]);
+    assert!(close(x0, 0.0) && close(y0, 0.0) && close(x1, 200.0) && close(y1, 100.0), "{x0} {y0} {x1} {y1}");
+}
diff --git a/crates/metafile/src/wmf.rs b/crates/metafile/src/wmf.rs
index e051471d87..d221a7655a 100644
--- a/crates/metafile/src/wmf.rs
+++ b/crates/metafile/src/wmf.rs
@@ -37,7 +37,13 @@ pub(crate) fn parse(input: Bytes) -> Result<(Canvas, Option<Frame>), Error> {
         return Err(Error::BadHeader);
     }
     let mut pos = hdr.checked_add(hsize.checked_mul(2).ok_or(Error::BadHeader)?).ok_or(Error::BadHeader)?;
+    // Played into a target like Word does: the placeable bounds are the first window, the target (the
+    // picture size) the viewport. A plain WMF's target is its first window.
     let mut cv = Canvas::new();
+    if let Some((c, size)) = bounds {
+        cv.play_into(Some([c[0], c[1], c[2] - c[0], c[3] - c[1]]), size);
+    }
+    let mut player_viewport = bounds.is_some();
     let mut parsed = 0usize;
     while !cv.full() {
         let (Some(words), Some(func)) = (input.u32(pos), pos.checked_add(4).and_then(|o| input.u16(o))) else { break };
@@ -47,6 +53,11 @@ pub(crate) fn parse(input: Bytes) -> Result<(Canvas, Option<Frame>), Error> {
             break;
         }
         record(&mut cv, func, Bytes(rec));
+        if func == 0x020C && cv.window_set && !player_viewport && !cv.viewport_set {
+            let we = cv.map.window_ext();
+            cv.play_into(None, (we.0.abs(), we.1.abs()));
+            player_viewport = true;
+        }
         parsed += 1;
         let Some(next) = pos.checked_add(len) else { break };
         pos = next;
@@ -55,12 +66,19 @@ pub(crate) fn parse(input: Bytes) -> Result<(Canvas, Option<Frame>), Error> {
         return Err(Error::NoRecords);
     }
     let frame = match bounds {
-        // The drawing is in device units, so the logical bounds go through the final mapping.
+        // Played into its target: the frame is the target.
+        Some((_, size)) if !cv.viewport_set && cv.map.uses_extents() => Some(Frame { rect: [0.0, 0.0, size.0, size.1], size: Some(size) }),
+        // The file set its own viewport, so the drawing is in its device units and the logical bounds
+        // go through the final mapping.
         Some((c, size)) => {
             let (a, b) = (cv.map.device((c[0], c[1])), cv.map.device((c[2], c[3])));
             let rect = [a.0.min(b.0), a.1.min(b.1), (b.0 - a.0).abs(), (b.1 - a.1).abs()];
             (rect[2] > 0.0 && rect[3] > 0.0).then_some(Frame { rect, size: Some(size) })
         }
+        None if player_viewport && !cv.viewport_set && cv.map.uses_extents() => {
+            let ve = cv.map.viewport_ext();
+            Some(Frame { rect: [0.0, 0.0, ve.0, ve.1], size: None })
+        }
         None if cv.window_set => Some(Frame { rect: cv.map.window_rect(), size: None }),
         None => None,
     };
@@ -74,6 +92,7 @@ fn record(cv: &mut Canvas, func: u16, r: Bytes) {
     let _ = match func {
         0x0103 => r.u16(6).map(|m| cv.set_map_mode(u32::from(m))),
         0x0106 => r.u16(6).map(|m| cv.set_polyfill(u32::from(m))),
+        0x0104 => r.u16(6).map(|m| cv.set_rop2(u32::from(m))),
         // Y is stored before X in these records.
         0x020B => xy16(r, 6).map(|p| cv.set_window_org(p)),
         0x020C => xy16(r, 6).map(|p| cv.set_window_ext(p)),
diff --git a/crates/pdf/src/lib.rs b/crates/pdf/src/lib.rs
index 28eee4d1a5..194b47e964 100644
--- a/crates/pdf/src/lib.rs
+++ b/crates/pdf/src/lib.rs
@@ -47,6 +47,7 @@ use wordcraft_doc::{Document, Path as DocPath, Rgb, StoryRef};
 use wordcraft_fonts::FaceRef;
 use wordcraft_geom::Rect;
 use wordcraft_layout::display::{DisplayOptions, Draw, Stroke as LineStyle, page_display};
+use wordcraft_layout::wordart::ArtPaint;
 use wordcraft_layout::{DocLayout, LayoutCache, LayoutOptions, Page, Placed, layout};
 use wordcraft_metafile::{Picture, PlacedItem};
 
@@ -77,20 +78,25 @@ pub struct PdfOptions {
     pub tagged: bool,
     /// Show tracked changes as markup (coloured, underlined / struck through).
     pub include_markup: bool,
+    /// Print Markup's comments: each page is scaled down to make room on its right for the
+    /// comments in balloons joined to their anchors (Word's "Document showing markup").
+    pub comments: bool,
     /// Compress content streams.
     pub compress: bool,
 }
 
 impl Default for PdfOptions {
     fn default() -> Self {
-        PdfOptions { pages: None, title: None, author: None, tagged: true, include_markup: false, compress: true }
+        PdfOptions { pages: None, title: None, author: None, tagged: true, include_markup: false, comments: false, compress: true }
     }
 }
 
 /// Lay out `doc` and write it as PDF. Without markup the layout is the final text: tracked
-/// deletions are left out, as in Word's "No Markup" view.
+/// deletions are left out, as in Word's "No Markup" view. With `comments` each page carries the
+/// markup area with the comment balloons.
 pub fn export(doc: &Document, opts: &PdfOptions) -> Result<Vec<u8>, PdfError> {
-    let lay = layout(doc, &mut LayoutCache::new(), &LayoutOptions { hide_deleted: !opts.include_markup, ..Default::default() });
+    let lo = LayoutOptions { hide_deleted: !opts.include_markup, comment_balloons: opts.comments, ..Default::default() };
+    let lay = layout(doc, &mut LayoutCache::new(), &lo);
     export_layout(doc, &lay, opts)
 }
 
@@ -154,16 +160,26 @@ fn write(doc: &Document, lay: &DocLayout, opts: &PdfOptions, pages: &[usize], ou
     if let Some(o) = ex.outline(pages) {
         pdf.set_outline(o);
     }
-    for (out, &pi) in pages.iter().enumerate() {
+    for &pi in pages {
         let Some(page) = lay.pages.get(pi) else { return Err(PdfError::BadPage(pi + 1)) };
-        let (w, h) = (clamp_side(page.w), clamp_side(page.h));
+        let fit = Fit::of(page);
+        let (w, h) = (clamp_side(fit.paper_w), clamp_side(page.h));
         let size = Size::from_wh(w, h).ok_or(PdfError::NoPages)?;
         let mut kp = pdf.start_page_with(PageSettings::new(size));
         let mut s = kp.surface();
         ex.links.clear();
+        // A page with a markup area is scaled down to fit its paper with the area beside it.
+        let scaled = fit.k < 1.0;
+        if scaled {
+            s.push_transform(&Transform::from_row(fit.k, 0.0, 0.0, fit.k, 0.0, fit.dy));
+        }
+        // `w` is the document page's width: the page colour and watermark stay off the markup area.
         ex.page(&mut s, page, w, h);
+        if scaled {
+            s.pop();
+        }
         s.finish();
-        for a in ex.annotations(out) {
+        for a in ex.annotations(fit) {
             kp.add_annotation(a);
         }
         kp.finish();
@@ -184,6 +200,32 @@ fn write(doc: &Document, lay: &DocLayout, opts: &PdfOptions, pages: &[usize], ou
     }
 }
 
+/// How a layout page maps onto its PDF page: a page with a markup area (Print Markup) is scaled
+/// by `k` to its paper width and centred vertically (`dy`); any other page is drawn as it is.
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct Fit {
+    paper_w: f32,
+    k: f32,
+    dy: f32,
+}
+
+impl Fit {
+    fn of(page: &Page) -> Fit {
+        let paper_w = page.w - page.markup;
+        if page.markup > 0.0 && ok(page.markup) && ok(page.w) && paper_w > 1.0 {
+            let k = paper_w / page.w;
+            Fit { paper_w, k, dy: page.h * (1.0 - k) / 2.0 }
+        } else {
+            Fit { paper_w: page.w, k: 1.0, dy: 0.0 }
+        }
+    }
+
+    /// A layout point on the PDF page.
+    fn point(self, x: f32, y: f32) -> (f32, f32) {
+        (x * self.k, y * self.k + self.dy)
+    }
+}
+
 /// The outlines of `glyphs` (glyph id, pen position) at `size`, as one path in page coordinates.
 fn glyph_outlines(face: &FaceRef, size: f32, glyphs: &[(u32, f32, f32)]) -> Option<Path> {
     let db = wordcraft_fonts::FontDb::global();
@@ -408,9 +450,15 @@ fn shape_path(kind: ShapeKind, r: &Rect) -> Option<Path> {
         ShapeKind::Ellipse => ellipse(&mut pb, cx, cy, r.w / 2.0, r.h / 2.0),
         ShapeKind::Triangle => poly(&mut pb, &[(cx, y0), (x1, y1), (x0, y1)]),
         ShapeKind::Diamond => poly(&mut pb, &[(cx, y0), (x1, cy), (cx, y1), (x0, cy)]),
+        // DrawingML's `line`: top-left to bottom-right (flips give the other directions).
         ShapeKind::Line => {
-            pb.move_to(x0, y1);
-            pb.line_to(x1, y0);
+            pb.move_to(x0, y0);
+            pb.line_to(x1, y1);
+        }
+        // Connectors are drawn as paths (`Draw::Path`); this is their frame's diagonal.
+        ShapeKind::StraightConnector | ShapeKind::ElbowConnector | ShapeKind::CurvedConnector => {
+            pb.move_to(x0, y0);
+            pb.line_to(x1, y1);
         }
         ShapeKind::Arrow => {
             let h = r.h;
@@ -818,6 +866,56 @@ impl Exporter<'_> {
                 s.set_fill(None);
                 s.set_stroke(None);
             }
+            Draw::Art { path, fx, color, alpha } => {
+                for l in wordcraft_layout::wordart::art_layers(path, fx, *color, *alpha) {
+                    let mut pb = PathBuilder::new();
+                    append_path(&mut pb, &l.path);
+                    let Some(p) = pb.finish() else { continue };
+                    let (paint, opacity): (krilla::paint::Paint, f32) = match &l.paint {
+                        ArtPaint::Solid(c, a) => (rgb::Color::new(c.0, c.1, c.2).into(), *a),
+                        ArtPaint::Linear { p0, p1, stops } => {
+                            let stops = stops
+                                .iter()
+                                .map(|(o, c, a)| krilla::paint::Stop {
+                                    offset: norm(*o),
+                                    color: rgb::Color::new(c.0, c.1, c.2).into(),
+                                    opacity: norm(*a),
+                                })
+                                .collect();
+                            let g = krilla::paint::LinearGradient {
+                                x1: p0.0,
+                                y1: p0.1,
+                                x2: p1.0,
+                                y2: p1.1,
+                                transform: Transform::default(),
+                                spread_method: krilla::paint::SpreadMethod::Pad,
+                                stops,
+                                anti_alias: true,
+                            };
+                            (g.into(), 1.0)
+                        }
+                    };
+                    match l.stroke {
+                        Some(w) => {
+                            s.set_fill(None);
+                            s.set_stroke(Some(Stroke {
+                                paint,
+                                width: w.clamp(0.1, 400.0),
+                                opacity: norm(opacity),
+                                line_join: LineJoin::Round,
+                                ..Default::default()
+                            }));
+                        }
+                        None => {
+                            s.set_stroke(None);
+                            s.set_fill(Some(Fill { paint, opacity: norm(opacity), rule: FillRule::NonZero }));
+                        }
+                    }
+                    s.draw_path(&p);
+                }
+                s.set_fill(None);
+                s.set_stroke(None);
+            }
             Draw::Mark { .. } | Draw::MarkText { .. } => {}
             Draw::Clip { rect, items } => {
                 let Some(clip) = rect_path(rect) else { return };
@@ -1109,9 +1207,28 @@ impl Exporter<'_> {
         }
     }
 
-    /// Where a bookmark is: (output page, x, y).
+    /// Where a bookmark is: (output page, x, y) — the page and line its start lands on, which
+    /// in a paragraph split across pages need not be the paragraph's first page.
     fn bookmark(&self, name: &str) -> Option<(usize, f32, f32)> {
         let (_, pos) = self.doc.bookmarks().into_iter().find(|(n, _)| n == name)?;
+        if let Some(c) = self.lay.caret(&pos)
+            && let Some(out) = self.out_index.get(&c.page)
+        {
+            // The left edge of the paragraph's piece on that page, at the top of the line.
+            let x = self
+                .lay
+                .index
+                .get(&(pos.story, pos.path.clone()))
+                .into_iter()
+                .flatten()
+                .filter(|(pi, _)| *pi == c.page)
+                .find_map(|(pi, ii)| match self.lay.pages.get(*pi).and_then(|p| p.items.get(*ii)) {
+                    Some(Placed::Lines { x, .. }) => Some(*x),
+                    _ => None,
+                })
+                .unwrap_or(c.x);
+            return Some((*out, x, c.top));
+        }
         self.locate(pos.story, &pos.path)
     }
 
@@ -1120,8 +1237,9 @@ impl Exporter<'_> {
         let places = self.lay.index.get(&(story, path.clone()))?;
         for (pi, ii) in places {
             let Some(out) = self.out_index.get(pi) else { continue };
-            let (x, y) = match self.lay.pages.get(*pi).and_then(|p| p.items.get(*ii)) {
-                Some(Placed::Lines { x, y, .. }) => (*x, *y),
+            let Some(page) = self.lay.pages.get(*pi) else { continue };
+            let (x, y) = match page.items.get(*ii) {
+                Some(Placed::Lines { x, y, .. }) => Fit::of(page).point(*x, *y),
                 _ => (0.0, 0.0),
             };
             return Some((*out, x, y));
@@ -1129,10 +1247,11 @@ impl Exporter<'_> {
         None
     }
 
-    fn annotations(&self, _out: usize) -> Vec<Annotation> {
+    fn annotations(&self, fit: Fit) -> Vec<Annotation> {
         let mut v = Vec::new();
         for (x0, y0, x1, y1, target) in &self.links {
-            let Some(rect) = krilla::geom::Rect::from_ltrb(*x0, *y0, *x1, *y1) else { continue };
+            let ((x0, y0), (x1, y1)) = (fit.point(*x0, *y0), fit.point(*x1, *y1));
+            let Some(rect) = krilla::geom::Rect::from_ltrb(x0, y0, x1, y1) else { continue };
             let t = if let Some(name) = target.strip_prefix('#') {
                 match self.bookmark(name) {
                     Some((page, x, y)) => Target::Destination(XyzDestination::new(page, Point::from_xy(x, y)).into()),
@@ -1163,7 +1282,8 @@ impl Exporter<'_> {
                 if title.is_empty() {
                     continue;
                 }
-                flat.push((level.min(8), title, out, *x, *y));
+                let (x, y) = Fit::of(page).point(*x, *y);
+                flat.push((level.min(8), title, out, x, y));
             }
         }
         if flat.is_empty() {
diff --git a/crates/pdf/src/tests.rs b/crates/pdf/src/tests.rs
index e75544cb01..5683e11b3f 100644
--- a/crates/pdf/src/tests.rs
+++ b/crates/pdf/src/tests.rs
@@ -764,3 +764,74 @@ fn cosmetic_metafile_pens_are_thin_but_visible() {
     let raw = String::from_utf8_lossy(&bytes);
     assert!(raw.contains("0.25 w"), "the hairline is a quarter point wide");
 }
+
+/// #455: a link to a bookmark after a page break inside its paragraph goes to the page the
+/// bookmark is on, not the paragraph's first page.
+#[test]
+fn bookmark_destination_is_the_page_of_its_start() {
+    let mut d = Document::new();
+    let mut p = Paragraph::with_text("Paragraph start\u{c}Bookmark target", CharProps::default());
+    let at = "Paragraph start\u{c}".len();
+    p.insert_object(at, InlineObject::BookmarkStart { name: "target".into() }, &CharProps::default()).unwrap();
+    p.insert_object(0, InlineObject::BookmarkStart { name: "first".into() }, &CharProps::default()).unwrap();
+    d.body = vec![para_block(p)];
+    let lay = layout(&d, &mut LayoutCache::new(), &LayoutOptions::default());
+    assert_eq!(lay.pages.len(), 2);
+    let pages: Vec<usize> = (0..lay.pages.len()).collect();
+    let outlined = HashSet::new();
+    let ex = Exporter {
+        doc: &d,
+        lay: &lay,
+        opts: &PdfOptions::default(),
+        out_index: pages.iter().enumerate().map(|(o, p)| (*p, o)).collect(),
+        fonts: HashMap::new(),
+        outlined: &outlined,
+        cmaps: HashMap::new(),
+        images: HashMap::new(),
+        vectors: HashMap::new(),
+        tags: Vec::new(),
+        tag_index: HashMap::new(),
+        links: Vec::new(),
+    };
+    let (page, x, y) = ex.bookmark("target").unwrap();
+    assert_eq!(page, 1, "the bookmark is on the second page");
+    assert!((x - 72.0).abs() < 1.0 && y < 150.0, "{x} {y}");
+    assert_eq!(ex.bookmark("first").map(|b| b.0), Some(0));
+}
+
+/// Print Markup (#589): the comments and their replies print beside each page, which is scaled
+/// down to keep its paper size; without it they stay out of the PDF.
+#[test]
+fn comments_print_in_balloons_beside_scaled_pages() {
+    let mut d = Document::from_text("Intro line.\nThe quarterly figures look strong.\nClosing line.");
+    let part = d.add_part(wordcraft_doc::PartKind::Comment, vec![para_block(Paragraph::with_text("Check the totals", CharProps::default()))]);
+    d.comments.insert(0, wordcraft_doc::Comment { author: "Ada Reviewer".into(), part, ..Default::default() });
+    let part = d.add_part(wordcraft_doc::PartKind::Comment, vec![para_block(Paragraph::with_text("Totals checked", CharProps::default()))]);
+    d.comments.insert(1, wordcraft_doc::Comment { author: "Ben Editor".into(), part, parent: Some(0), ..Default::default() });
+    d.insert_object(&wordcraft_doc::Pos::body(1, 13), InlineObject::CommentEnd { id: 0 }, &CharProps::default()).unwrap();
+    d.insert_object(&wordcraft_doc::Pos::body(1, 4), InlineObject::CommentStart { id: 0 }, &CharProps::default()).unwrap();
+    let size = |bytes: &[u8]| {
+        let pdf = hayro_syntax::Pdf::new(bytes.to_vec()).expect("parse");
+        pdf.pages().iter().map(|p| p.media_box()).map(|r| (r.width().round(), r.height().round())).collect::<Vec<_>>()
+    };
+    let plain = export(&d, &PdfOptions::default()).unwrap();
+    let text = squash(&extract_text(&plain).concat());
+    assert!(text.contains("quarterly figures") && !text.contains("Check the totals") && !text.contains("Ada Reviewer"), "{text}");
+    let marked = export(&d, &PdfOptions { include_markup: true, comments: true, ..Default::default() }).unwrap();
+    let text = squash(&extract_text(&marked).concat());
+    for want in ["quarterly figures", "Ada Reviewer", "Check the totals", "Ben Editor", "Totals checked"] {
+        assert!(text.contains(want), "{want} missing: {text}");
+    }
+    // Same paper: the page and its markup area are scaled to fit it.
+    assert_eq!(size(&plain), size(&marked));
+    assert_eq!(size(&marked), vec![(612.0, 792.0)]);
+    // Tagged or not, with links and an outline, it still writes.
+    let mut d2 = sample();
+    let part = d2.add_part(wordcraft_doc::PartKind::Comment, vec![para_block(Paragraph::with_text("On the heading", CharProps::default()))]);
+    d2.comments.insert(0, wordcraft_doc::Comment { author: "Ada".into(), part, ..Default::default() });
+    d2.insert_object(&wordcraft_doc::Pos::body(1, 3), InlineObject::CommentStart { id: 0 }, &CharProps::default()).unwrap();
+    for tagged in [false, true] {
+        let bytes = export(&d2, &PdfOptions { tagged, comments: true, ..Default::default() }).unwrap();
+        assert!(squash(&extract_text(&bytes).concat()).contains("On the heading"));
+    }
+}
diff --git a/crates/proof/src/lib.rs b/crates/proof/src/lib.rs
index a44971a295..925ab7ecfa 100644
--- a/crates/proof/src/lib.rs
+++ b/crates/proof/src/lib.rs
@@ -29,8 +29,26 @@ pub mod pl;
 
 use std::collections::HashSet;
 use std::ops::Range;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{OnceLock, RwLock};
 
+/// What the spelling check skips (File › Options › Proofing). Word's defaults: all on.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct Options {
+    /// Words in capitals (`NASA`, `WORDCRAFT`) are taken as correct.
+    pub ignore_uppercase: bool,
+    /// Words containing digits (`B2B`, `mp3`) are taken as correct.
+    pub ignore_numbers: bool,
+    /// Web and email addresses and file paths (`https://…`, `a@b.org`, `www.…`) are skipped.
+    pub ignore_internet: bool,
+}
+
+impl Default for Options {
+    fn default() -> Self {
+        Options { ignore_uppercase: true, ignore_numbers: true, ignore_internet: true }
+    }
+}
+
 pub use lang::ProofLang;
 
 /// A problem found in text: byte range, kind, message and suggestions.
@@ -58,9 +76,28 @@ fn user_words() -> &'static RwLock<HashSet<String>> {
     U.get_or_init(|| RwLock::new(HashSet::new()))
 }
 
+/// Bumped whenever the user dictionary changes, so cached proofing results can be dropped.
+static DICTIONARY_GENERATION: AtomicU64 = AtomicU64::new(0);
+
 /// Add a word to the user dictionary ("Add to Dictionary"). It applies to every language.
 pub fn add_word(w: &str) {
-    user_words().write().unwrap_or_else(|e| e.into_inner()).insert(w.to_lowercase());
+    if user_words().write().unwrap_or_else(|e| e.into_inner()).insert(w.to_lowercase()) {
+        DICTIONARY_GENERATION.fetch_add(1, Ordering::Relaxed);
+    }
+}
+
+/// Take a word out of the user dictionary (File › Options › Proofing). Returns whether it was there.
+pub fn remove_word(w: &str) -> bool {
+    let removed = user_words().write().unwrap_or_else(|e| e.into_inner()).remove(&w.to_lowercase());
+    if removed {
+        DICTIONARY_GENERATION.fetch_add(1, Ordering::Relaxed);
+    }
+    removed
+}
+
+/// A number that changes whenever a word is added to or removed from the user dictionary.
+pub fn dictionary_generation() -> u64 {
+    DICTIONARY_GENERATION.load(Ordering::Relaxed)
 }
 
 /// Is `lower` (a lower-case word) in the user dictionary?
@@ -152,12 +189,25 @@ fn known_core(w: &str) -> bool {
 /// Is `word` spelled correctly? Numbers, single letters, ALL-CAPS acronyms, URLs and words with
 /// digits are accepted.
 pub fn is_correct(word: &str) -> bool {
+    is_correct_with(word, &Options::default())
+}
+
+/// The words every language's check accepts under `opts`: single letters, words without
+/// letters, words with digits (Ignore words that contain numbers) and words in capitals
+/// (Ignore words in UPPERCASE).
+fn accepted_by_options(word: &str, opts: &Options) -> bool {
+    let w = word.trim_matches(|c: char| !c.is_alphanumeric() && c != '\'').trim_matches('\'');
+    w.chars().count() <= 1
+        || !w.chars().any(char::is_alphabetic)
+        || (opts.ignore_numbers && w.chars().any(|c| c.is_ascii_digit()))
+        || (opts.ignore_uppercase && w.chars().all(|c| !c.is_lowercase()))
+}
+
+/// [`is_correct`] with the File › Options › Proofing choices.
+pub fn is_correct_with(word: &str, opts: &Options) -> bool {
     let w = word.trim_matches(|c: char| !c.is_alphanumeric() && c != '\'');
     let w = w.trim_matches('\'');
-    if w.chars().count() <= 1 || w.chars().any(|c| c.is_ascii_digit()) || !w.chars().any(char::is_alphabetic) {
-        return true;
-    }
-    if w.chars().all(|c| !c.is_lowercase()) && w.chars().count() <= 6 {
+    if accepted_by_options(w, opts) {
         return true;
     }
     if !w.is_ascii() && !w.chars().any(|c| c.is_ascii_alphabetic()) {
@@ -280,7 +330,12 @@ pub fn words(text: &str) -> Vec<(usize, usize)> {
 
 /// Spelling issues in a paragraph of English text (no suggestions; ask [`suggest`] on demand).
 pub fn check_spelling(text: &str) -> Vec<Issue> {
-    check_spelling_in(text, ProofLang::En)
+    check_spelling_with(text, &Options::default())
+}
+
+/// [`check_spelling`] with the File › Options › Proofing choices.
+pub fn check_spelling_with(text: &str, opts: &Options) -> Vec<Issue> {
+    words(text).into_iter().filter_map(|(a, b)| spelling_issue(text, a, b, ProofLang::En, opts)).collect()
 }
 
 /// Spelling issues in a paragraph of text in `lang` (none for a language without a dictionary;
@@ -289,17 +344,18 @@ pub fn check_spelling_in(text: &str, lang: ProofLang) -> Vec<Issue> {
     if !lang.is_proofed() {
         return Vec::new();
     }
-    words(text).into_iter().filter_map(|(a, b)| spelling_issue(text, a, b, lang)).collect()
+    words(text).into_iter().filter_map(|(a, b)| spelling_issue(text, a, b, lang, &Options::default())).collect()
 }
 
 /// The spelling issue of the word at `a..b` of `text`, if it is misspelled in `lang`. Words in
-/// web and e-mail addresses are skipped.
-fn spelling_issue(text: &str, a: usize, b: usize, lang: ProofLang) -> Option<Issue> {
+/// web and e-mail addresses are skipped (unless `opts` says otherwise).
+fn spelling_issue(text: &str, a: usize, b: usize, lang: ProofLang, opts: &Options) -> Option<Issue> {
     let w = text.get(a..b)?;
     let ts = text.get(..a).and_then(|t| t.rfind(char::is_whitespace)).map(|i| i + 1).unwrap_or(0);
     let te = text.get(b..).and_then(|t| t.find(char::is_whitespace)).map(|i| b + i).unwrap_or(text.len());
     let token = text.get(ts..te).unwrap_or("");
-    if token.contains("://") || token.contains('@') || token.starts_with("www.") || is_correct_in(w, lang) {
+    let internet = token.contains("://") || token.contains('@') || token.starts_with("www.");
+    if (opts.ignore_internet && internet) || is_correct_in_with(w, lang, opts) {
         return None;
     }
     let message = match lang {
@@ -311,9 +367,14 @@ fn spelling_issue(text: &str, a: usize, b: usize, lang: ProofLang) -> Option<Iss
 
 /// Is `word` spelled correctly in `lang`? Always true in a language without a dictionary.
 pub fn is_correct_in(word: &str, lang: ProofLang) -> bool {
+    is_correct_in_with(word, lang, &Options::default())
+}
+
+/// [`is_correct_in`] with the File › Options › Proofing choices.
+pub fn is_correct_in_with(word: &str, lang: ProofLang, opts: &Options) -> bool {
     match lang {
-        ProofLang::En => is_correct(word),
-        ProofLang::Pl => pl::is_correct(word),
+        ProofLang::En => is_correct_with(word, opts),
+        ProofLang::Pl => accepted_by_options(word, opts) || pl::is_correct(word),
         ProofLang::Other => true,
     }
 }
@@ -344,6 +405,12 @@ pub fn check_grammar_in(text: &str, lang: ProofLang) -> Vec<Issue> {
 /// inside that language's spans: an English quotation in a Polish paragraph gets English
 /// spelling and is never told a Polish rule.
 pub fn check_text(text: &str, spans: &[(Range<usize>, ProofLang)]) -> Vec<Issue> {
+    check_text_with(text, spans, &Options::default(), true)
+}
+
+/// [`check_text`] with the File › Options › Proofing choices: what spelling skips, and whether
+/// grammar is checked at all.
+pub fn check_text_with(text: &str, spans: &[(Range<usize>, ProofLang)], opts: &Options, grammar: bool) -> Vec<Issue> {
     // Sorted, empty ones dropped, neighbours of one language merged.
     let mut sorted: Vec<&(Range<usize>, ProofLang)> = spans.iter().filter(|(r, _)| r.start < r.end).collect();
     sorted.sort_by_key(|s| s.0.start);
@@ -358,7 +425,11 @@ pub fn check_text(text: &str, spans: &[(Range<usize>, ProofLang)]) -> Vec<Issue>
         let k = merged.partition_point(|(r, _)| r.end <= i);
         merged.get(k).filter(|(r, _)| r.start <= i).map_or(ProofLang::En, |s| s.1)
     };
-    let mut v: Vec<Issue> = words(text).into_iter().filter_map(|(a, b)| spelling_issue(text, a, b, lang_at(a))).collect();
+    let mut v: Vec<Issue> = words(text).into_iter().filter_map(|(a, b)| spelling_issue(text, a, b, lang_at(a), opts)).collect();
+    if !grammar {
+        v.sort_by_key(|i| (i.start, i.end));
+        return v;
+    }
     let mut langs: Vec<ProofLang> = merged.iter().map(|s| s.1).collect();
     let mut covered = 0;
     for (r, _) in &merged {
@@ -591,6 +662,18 @@ mod tests {
         assert!(is_correct("zxqwordcrafty"));
     }
 
+    /// File › Options › Proofing (#485): each "Ignore" choice turned off makes those words count.
+    #[test]
+    fn ignore_options_decide_what_is_checked() {
+        let t = "SENTENSE helo2 www.exampel.org";
+        let bad = |o: Options| check_spelling_with(t, &o).iter().map(|i| t[i.start..i.end].to_string()).collect::<Vec<_>>();
+        assert!(bad(Options::default()).is_empty(), "Word's defaults skip all three");
+        let all = Options { ignore_uppercase: false, ignore_numbers: false, ignore_internet: false };
+        assert_eq!(bad(all), ["SENTENSE", "helo2", "www", "exampel"]);
+        assert_eq!(bad(Options { ignore_uppercase: false, ..Options::default() }), ["SENTENSE"]);
+        assert!(is_correct_with("NASA", &all), "capitals that are a word stay correct");
+    }
+
     #[test]
     fn hyphenation() {
         let l = hyphen::Limits::default();
diff --git a/crates/render/src/lib.rs b/crates/render/src/lib.rs
index a2d464116a..a81347a5de 100644
--- a/crates/render/src/lib.rs
+++ b/crates/render/src/lib.rs
@@ -13,6 +13,7 @@ use wordcraft_doc::props::Rgb;
 use wordcraft_fonts::FontDb;
 use wordcraft_layout::Page;
 use wordcraft_layout::display::{DisplayOptions, Draw, Stroke, page_display};
+use wordcraft_layout::wordart::ArtPaint;
 use wordcraft_metafile::{Item, Picture, PlacedItem, Seg};
 
 pub mod icon_lib;
@@ -420,11 +421,13 @@ fn draw_watermark(ctx: &mut RenderContext, view: Affine, page: &Page, wm: &wordc
     if raw_w <= 0.0 {
         return;
     }
-    let diag = if wm.diagonal { ((page.w as f64).powi(2) + (page.h.min(2000.0) as f64).powi(2)).sqrt() } else { page.w as f64 };
+    // The document page, not a Print Markup area beside it.
+    let pw = (page.w - page.markup.max(0.0)).max(1.0) as f64;
+    let diag = if wm.diagonal { (pw.powi(2) + (page.h.min(2000.0) as f64).powi(2)).sqrt() } else { pw };
     let size = (diag * 0.5 / raw_w).min(200.0);
     let k = size / upem;
-    let angle = if wm.diagonal { -((page.h.min(2000.0) as f64) / page.w.max(1.0) as f64).atan() } else { 0.0 };
-    let base = Affine::translate((page.w as f64 / 2.0, page.h.min(2000.0) as f64 / 2.0))
+    let angle = if wm.diagonal { -((page.h.min(2000.0) as f64) / pw).atan() } else { 0.0 };
+    let base = Affine::translate((pw / 2.0, page.h.min(2000.0) as f64 / 2.0))
         * Affine::rotate(angle)
         * Affine::translate((-raw_w * size / 2.0, size * 0.35));
     ctx.set_paint(color(opts.ink(wm.color), if wm.semitransparent { 0.35 } else { 0.8 }));
@@ -523,6 +526,10 @@ fn draw(ctx: &mut RenderContext, doc: &Document, it: &Draw, view: Affine, visibl
             line(ctx, 0.0);
         }
         Draw::Glyphs { face, size, glyphs, color: c, alpha, synth_bold, synth_italic, .. } => {
+            // Invisible glyphs (WordArt letters are drawn from their outlines) carry text only.
+            if *alpha <= 0.0 {
+                return;
+            }
             let db = FontDb::global();
             let k = *size as f64 / face.upem.max(1.0);
             ctx.set_paint(color(opts.ink(*c), *alpha));
@@ -650,6 +657,32 @@ fn draw(ctx: &mut RenderContext, doc: &Document, it: &Draw, view: Affine, visibl
                 ctx.stroke_path(&path);
             }
         }
+        Draw::Art { path, fx, color: c, alpha } => {
+            let Some(b) = wordcraft_layout::wordart::path_box(path) else { return };
+            if !b.inflate(200.0, 200.0).overlaps(*visible) {
+                return;
+            }
+            ctx.set_transform(view);
+            for l in wordcraft_layout::wordart::art_layers(path, fx, *c, *alpha) {
+                match &l.paint {
+                    ArtPaint::Solid(c, a) => ctx.set_paint(color(opts.ink(*c), *a)),
+                    ArtPaint::Linear { p0, p1, stops } => {
+                        let stops: Vec<peniko::ColorStop> =
+                            stops.iter().map(|(o, c, a)| peniko::ColorStop::from((o.clamp(0.0, 1.0), color(opts.ink(*c), *a)))).collect();
+                        let g = peniko::Gradient::new_linear((f64::from(p0.0), f64::from(p0.1)), (f64::from(p1.0), f64::from(p1.1)))
+                            .with_stops(stops.as_slice());
+                        ctx.set_paint(g);
+                    }
+                }
+                match l.stroke {
+                    Some(w) => {
+                        ctx.set_stroke(kurbo::Stroke::new(f64::from(w.clamp(0.1, 400.0))).with_join(kurbo::Join::Round));
+                        ctx.stroke_path(&l.path);
+                    }
+                    None => ctx.fill_path(&l.path),
+                }
+            }
+        }
         Draw::Ink { pts, color: c, width, alpha } => {
             let Some(path) = ink_path(pts) else { return };
             if !path.bounding_box().inflate(*width as f64, *width as f64).overlaps(*visible) {
@@ -793,10 +826,18 @@ pub fn shape_path(kind: ShapeKind, r: kurbo::Rect) -> BezPath {
         ShapeKind::Ellipse => kurbo::Ellipse::from_rect(r).to_path(0.1),
         ShapeKind::Triangle => poly(&[(cx, r.y0), (r.x1, r.y1), (r.x0, r.y1)]),
         ShapeKind::Diamond => poly(&[(cx, r.y0), (r.x1, cy), (cx, r.y1), (r.x0, cy)]),
+        // DrawingML's `line`: top-left to bottom-right (flips give the other directions).
         ShapeKind::Line => {
             let mut p = BezPath::new();
-            p.move_to((r.x0, r.y1));
-            p.line_to((r.x1, r.y0));
+            p.move_to((r.x0, r.y0));
+            p.line_to((r.x1, r.y1));
+            p
+        }
+        // Connectors are drawn as paths (`Draw::Path`); this is their frame's diagonal.
+        ShapeKind::StraightConnector | ShapeKind::ElbowConnector | ShapeKind::CurvedConnector => {
+            let mut p = BezPath::new();
+            p.move_to((r.x0, r.y0));
+            p.line_to((r.x1, r.y1));
             p
         }
         ShapeKind::Arrow => {
@@ -902,6 +943,7 @@ mod tests {
                 story: None,
                 freeform: None,
                 effects,
+                extra: Default::default(),
             };
             let at = wordcraft_doc::Pos { story: wordcraft_doc::StoryRef::Body, path: wordcraft_doc::Path::top(0), off: 0 };
             d.insert_object(&at, shape, &Default::default()).unwrap();
@@ -1163,6 +1205,14 @@ mod tests {
             assert!(!shape_path(k, r).elements().is_empty());
         }
     }
+
+    /// #611: a line runs as DrawingML's `line` preset does, top-left to bottom-right (Word's
+    /// files flip it for the other diagonal), not bottom-left to top-right.
+    #[test]
+    fn a_line_runs_from_top_left_to_bottom_right() {
+        let p = shape_path(ShapeKind::Line, kurbo::Rect::new(10.0, 20.0, 30.0, 60.0));
+        assert_eq!(p.elements(), &[kurbo::PathEl::MoveTo((10.0, 20.0).into()), kurbo::PathEl::LineTo((30.0, 60.0).into())]);
+    }
 }
 
 #[cfg(test)]
diff --git a/crates/ui-egui/src/a11y.rs b/crates/ui-egui/src/a11y.rs
new file mode 100644
index 0000000000..240183e450
--- /dev/null
+++ b/crates/ui-egui/src/a11y.rs
@@ -0,0 +1,659 @@
+//! Screen readers read the document (#488). The canvas draws pages as pictures, so on its own it
+//! is one opaque widget to assistive technology. This module describes the document under it as
+//! an AccessKit tree, the way a browser describes a page:
+//!
+//! - the canvas widget is the **document** node (named after the document), holding the caret
+//!   and selection as an AccessKit text selection;
+//! - each body paragraph is a **paragraph**, a **heading** (with its outline level) or a **list
+//!   item** (with its list level, grouped into lists), holding one **text run** per laid-out line
+//!   with its characters' screen positions, so a reader can follow the caret by character, word
+//!   and line and point at text;
+//! - tables are **table → row → cell**, pictures and charts **images** named by their alt text,
+//!   hyperlinks **links** around their text runs; list numbers are **list markers**.
+//!
+//! Only the pages on screen and one page either side are described, and the tree is capped, so a
+//! long document costs no more than a short one. Nothing is built unless a screen reader (or a
+//! test) asked egui for AccessKit output; the tree is rebuilt only when the layout, the selection,
+//! the described pages or their place on screen changed.
+
+use std::collections::{HashMap, HashSet};
+use std::sync::Arc;
+
+use egui::accesskit::{self, Node, NodeId, Role, TextPosition, TextSelection};
+use egui::{Id, Rect};
+use wordcraft_doc::para::InlineObject;
+use wordcraft_doc::props::TextDirection;
+use wordcraft_doc::{Document, Path, Pos, StoryRef};
+use wordcraft_layout::para::{ClKind, Line};
+use wordcraft_layout::{DocLayout, LineEnd, ParaLayout, Placed};
+
+/// Most nodes described at once (a dense page has a few hundred).
+pub const MAX_NODES: usize = 6000;
+/// AccessKit's word starts are `u8`s: a text run holds at most this many characters.
+const MAX_RUN: usize = 255;
+/// Deepest table nesting described (paths come from files).
+const MAX_DEPTH: usize = 16;
+
+/// What was described last frame, and for what.
+#[derive(Default)]
+pub struct A11yCache {
+    key: Option<Key>,
+    tree: Tree,
+}
+
+struct Key {
+    layout: Arc<DocLayout>,
+    doc: Id,
+    pages: (usize, usize),
+    rects: Vec<Rect>,
+    sel: (Pos, Pos),
+}
+
+impl Key {
+    fn same(&self, o: &Key) -> bool {
+        Arc::ptr_eq(&self.layout, &o.layout) && self.doc == o.doc && self.pages == o.pages && self.rects == o.rects && self.sel == o.sel
+    }
+}
+
+/// The described document: its nodes (in creation order), the document node's children and the
+/// selection inside it.
+#[derive(Default, Clone)]
+pub struct Tree {
+    pub nodes: Vec<(Id, Node)>,
+    pub top: Vec<NodeId>,
+    pub selection: Option<TextSelection>,
+}
+
+/// The pages to describe: those meeting `view`, and one either side.
+pub fn page_window(rects: &[Rect], view: Rect) -> Option<(usize, usize)> {
+    let first = rects.iter().position(|r| r.intersects(view))?;
+    let last = rects.iter().rposition(|r| r.intersects(view)).unwrap_or(first);
+    Some((first.saturating_sub(1), (last + 2).min(rects.len())))
+}
+
+/// Describe the document under the canvas widget `doc_id` to AccessKit for this frame.
+/// `rects` are the pages' screen rectangles, `view` the visible part of the canvas.
+pub fn expose(app: &mut crate::WordApp, ctx: &egui::Context, doc_id: Id, layout: &Arc<DocLayout>, rects: &[Rect], view: Rect) {
+    if ctx.accesskit_node_builder(doc_id, |n| n.set_role(Role::Document)).is_none() {
+        // No screen reader: describe nothing, keep nothing.
+        app.canvas.a11y = A11yCache::default();
+        return;
+    }
+    let pages = page_window(rects, view).unwrap_or((0, 0));
+    let sel = (app.session.sel.anchor.clone(), app.session.sel.focus.clone());
+    let key = Key { layout: layout.clone(), doc: doc_id, pages, rects: rects.get(pages.0..pages.1).unwrap_or_default().to_vec(), sel };
+    if !app.canvas.a11y.key.as_ref().is_some_and(|k| k.same(&key)) {
+        app.canvas.a11y.tree = build(&app.session.doc, layout, doc_id, rects, pages, (&key.sel.0, &key.sel.1));
+        app.canvas.a11y.key = Some(key);
+    }
+    let title = app.title_stem();
+    let tree = &app.canvas.a11y.tree;
+    let ours: HashSet<NodeId> = tree.nodes.iter().map(|(id, _)| id.accesskit_id()).collect();
+    for (id, node) in &tree.nodes {
+        ctx.accesskit_node_builder(*id, |n| *n = node.clone());
+    }
+    // egui hangs every new node off the window; ours belong under the document.
+    ctx.accesskit_node_builder(egui::accesskit_root_id(), |root| {
+        let keep: Vec<NodeId> = root.children().iter().filter(|c| !ours.contains(c)).copied().collect();
+        root.set_children(keep);
+    });
+    ctx.accesskit_node_builder(doc_id, |n| {
+        n.set_label(title);
+        for c in &tree.top {
+            n.push_child(*c);
+        }
+        match &tree.selection {
+            Some(s) => n.set_text_selection(*s),
+            None => n.clear_text_selection(),
+        }
+    });
+}
+
+/// Build the description of pages `pages.0..pages.1`.
+pub fn build(doc: &Document, layout: &DocLayout, doc_id: Id, rects: &[Rect], pages: (usize, usize), sel: (&Pos, &Pos)) -> Tree {
+    let mut b = Builder { doc, doc_id, tree: Tree::default(), index: HashMap::new(), lists: HashMap::new(), offsets: HashMap::new() };
+    for pi in pages.0..pages.1 {
+        let (Some(page), Some(pr)) = (layout.pages.get(pi), rects.get(pi)) else { continue };
+        let scale = crate::canvas::page_screen_scale(*pr, page, 1.0);
+        let to_screen = |r: wordcraft_geom::Rect| {
+            Rect::from_min_size(egui::pos2(pr.min.x + r.x * scale, pr.min.y + r.y * scale), egui::vec2(r.w * scale, r.h * scale))
+        };
+        // Where floating pictures sit (their anchor character takes no room on its line).
+        let mut pictures: HashMap<(&[u32], usize), Rect> = HashMap::new();
+        for it in &page.items {
+            if let Placed::Image { rect, story: StoryRef::Body, path, off, .. } | Placed::Graphic { rect, story: StoryRef::Body, path, off, .. } = it
+            {
+                pictures.insert((path.0.as_slice(), *off), to_screen(*rect));
+            }
+        }
+        for it in &page.items {
+            if b.full() {
+                break;
+            }
+            let Placed::Lines { story: StoryRef::Body, path, para, l0, l1, x, y, turn } = it else { continue };
+            let place = LinePlace { x: *x, y: *y, turn: *turn, scale, origin: pr.min };
+            b.paragraph(path, para, *l0..*l1, &place, &pictures);
+        }
+    }
+    let at = |p: &Pos| if p.story == StoryRef::Body { b.position(&p.path, p.off) } else { None };
+    b.tree.selection = match (at(sel.0), at(sel.1)) {
+        (Some(anchor), Some(focus)) => Some(TextSelection { anchor, focus }),
+        (None, Some(focus)) => Some(TextSelection { anchor: focus, focus }),
+        _ => None,
+    };
+    b.tree
+}
+
+/// Where a paragraph's lines are placed: the `Placed::Lines` frame and the page on screen.
+struct LinePlace {
+    x: f32,
+    y: f32,
+    turn: TextDirection,
+    scale: f32,
+    origin: egui::Pos2,
+}
+
+impl LinePlace {
+    fn rect(&self, r: wordcraft_geom::Rect) -> Rect {
+        let p = wordcraft_layout::turn_rect(self.turn, self.x, self.y, r);
+        let s = self.scale;
+        Rect::from_min_size(egui::pos2(self.origin.x + p.x * s, self.origin.y + p.y * s), egui::vec2(p.w * s, p.h * s))
+    }
+}
+
+struct Builder<'a> {
+    doc: &'a Document,
+    doc_id: Id,
+    tree: Tree,
+    index: HashMap<Id, usize>,
+    /// Per container: the list being filled and the block index of its last item.
+    lists: HashMap<Id, (Id, usize)>,
+    /// Per paragraph: (byte offset, text run, character index) of each cluster, in text order.
+    offsets: HashMap<Vec<u32>, Vec<(usize, Id, usize)>>,
+}
+
+/// One text run being gathered.
+#[derive(Default)]
+struct Run {
+    text: String,
+    lens: Vec<u8>,
+    /// Paragraph x of each character's left edge and its width (points).
+    xs: Vec<(f32, f32)>,
+    link: Option<String>,
+}
+
+impl Builder<'_> {
+    fn full(&self) -> bool {
+        self.tree.nodes.len() >= MAX_NODES
+    }
+
+    /// Add a node under `parent` (the document when `None`). False when it exists or the tree is full.
+    fn add(&mut self, id: Id, parent: Option<Id>, node: Node) -> bool {
+        if self.index.contains_key(&id) || self.full() {
+            return false;
+        }
+        match parent {
+            Some(p) => match self.index.get(&p).and_then(|&i| self.tree.nodes.get_mut(i)) {
+                Some((_, pn)) => pn.push_child(id.accesskit_id()),
+                None => return false,
+            },
+            None => self.tree.top.push(id.accesskit_id()),
+        }
+        self.index.insert(id, self.tree.nodes.len());
+        self.tree.nodes.push((id, node));
+        true
+    }
+
+    fn node_mut(&mut self, id: Id) -> Option<&mut Node> {
+        let i = *self.index.get(&id)?;
+        self.tree.nodes.get_mut(i).map(|(_, n)| n)
+    }
+
+    /// The node blocks at `path` sit in: the document, or a table cell (made on first use, with
+    /// its row and table).
+    fn container(&mut self, path: &[u32]) -> Option<Id> {
+        if path.len() <= 1 {
+            return Some(self.doc_id);
+        }
+        if path.len() < 4 || path.len() > MAX_DEPTH * 3 + 1 {
+            return None;
+        }
+        let n = path.len();
+        let (tpath, rpath, cpath) = (path.get(..n - 3)?, path.get(..n - 2)?, path.get(..n - 1)?);
+        let (row, col) = (*path.get(n - 3)? as usize, *path.get(n - 2)? as usize);
+        let (tid, rid, cid) = (self.doc_id.with(("table", tpath)), self.doc_id.with(("row", rpath)), self.doc_id.with(("cell", cpath)));
+        if !self.index.contains_key(&tid) {
+            let parent = self.container(tpath)?;
+            let mut t = Node::new(Role::Table);
+            if let Some(tb) = self.doc.block(StoryRef::Body, &Path(tpath.to_vec())).and_then(|b| b.as_table()) {
+                t.set_row_count(tb.rows.len());
+                t.set_column_count(tb.grid.len());
+            }
+            self.add(tid, (parent != self.doc_id).then_some(parent), t);
+        }
+        if !self.index.contains_key(&rid) {
+            let mut r = Node::new(Role::Row);
+            r.set_row_index(row);
+            self.add(rid, Some(tid), r);
+        }
+        if !self.index.contains_key(&cid) {
+            let mut c = Node::new(Role::Cell);
+            c.set_row_index(row);
+            c.set_column_index(col);
+            self.add(cid, Some(rid), c);
+        }
+        self.index.contains_key(&cid).then_some(cid)
+    }
+
+    /// The paragraph at `path`, made on first sight (later pieces of it add lines).
+    fn para_node(&mut self, path: &Path, para: &ParaLayout) -> Option<Id> {
+        let id = self.doc_id.with(("para", path.0.as_slice()));
+        if self.index.contains_key(&id) {
+            return Some(id);
+        }
+        let container = self.container(&path.0)?;
+        let parent = (container != self.doc_id).then_some(container);
+        let block = path.last();
+        let heading = para.rp.outline_level.filter(|l| *l < 9);
+        let list = para.rp.numbering.filter(|n| n.num != 0 && para.label.is_some());
+        let node = match (heading, list) {
+            (Some(l), _) => {
+                let mut n = Node::new(Role::Heading);
+                n.set_level(l as usize + 1);
+                n
+            }
+            (None, Some(num)) => {
+                let mut n = Node::new(Role::ListItem);
+                n.set_level(num.level as usize + 1);
+                n
+            }
+            (None, None) => Node::new(Role::Paragraph),
+        };
+        let parent = if list.is_some() && heading.is_none() {
+            // Consecutive list paragraphs share a list.
+            let lid = match self.lists.get(&container) {
+                Some((lid, last)) if last + 1 == block && self.index.contains_key(lid) => *lid,
+                _ => {
+                    let lid = container.with(("list", block));
+                    if !self.add(lid, parent, Node::new(Role::List)) {
+                        return None;
+                    }
+                    lid
+                }
+            };
+            self.lists.insert(container, (lid, block));
+            Some(lid)
+        } else {
+            parent
+        };
+        if !self.add(id, parent, node) {
+            return None;
+        }
+        if let Some(label) = para.label.as_ref().filter(|l| !l.text.trim().is_empty()) {
+            let mut m = Node::new(Role::ListMarker);
+            // Symbol-font bullets are private-use characters: say them as bullets.
+            m.set_value(label.text.chars().map(|c| if ('\u{E000}'..='\u{F8FF}').contains(&c) { '•' } else { c }).collect::<String>());
+            self.add(id.with("marker"), Some(id), m);
+        }
+        Some(id)
+    }
+
+    /// Lines `lines` of the paragraph at `path`: text runs (split at links, pictures and the
+    /// run length limit), links and pictures.
+    fn paragraph(
+        &mut self,
+        path: &Path,
+        para: &ParaLayout,
+        lines: std::ops::Range<usize>,
+        at: &LinePlace,
+        pictures: &HashMap<(&[u32], usize), Rect>,
+    ) {
+        let Some(pid) = self.para_node(path, para) else { return };
+        let Some(dp) = self.doc.para(StoryRef::Body, path) else { return };
+        let links = links(dp);
+        let first_top = para.lines.get(lines.start).map_or(0.0, |l| l.top);
+        for li in lines {
+            let Some(line) = para.lines.get(li) else { break };
+            if self.full() || self.index.contains_key(&pid.with(("run", li, 0usize))) {
+                // A repeated table header row shows the same lines again.
+                continue;
+            }
+            let mut lb = LineBuild { pid, li, seg: 0, prev: None, top: line.top - first_top, run: Run::default(), map: Vec::new() };
+            for k in line.c0..line.c1 {
+                let Some(cl) = para.clusters.get(k) else { break };
+                lb.map.push((cl.start, lb.seg, lb.run.lens.len()));
+                let shown = para.shown.binary_search_by_key(&k, |s| s.0).ok().and_then(|i| para.shown.get(i)).map(|s| s.1.as_str());
+                let text = match (cl.kind, shown) {
+                    (_, Some(s)) => s,
+                    (ClKind::Text | ClKind::Space, None) => dp.text.get(cl.start..cl.end).unwrap_or(""),
+                    (ClKind::Tab, None) => "\t",
+                    (ClKind::LineBreak, None) => "\n",
+                    (ClKind::Object(_), None) => {
+                        let picture = match dp.object_at(cl.start) {
+                            Some(InlineObject::Image { alt, .. } | InlineObject::Graphic { alt, .. }) => Some(alt.clone()),
+                            _ => None,
+                        };
+                        if let Some(alt) = picture {
+                            if !lb.run.lens.is_empty() {
+                                self.flush(&mut lb, line, at);
+                            }
+                            let rect = pictures.get(&(path.0.as_slice(), cl.start)).copied().or_else(|| {
+                                let (x0, x1) = (line.cl_left(k)?, line.cl_right(k)?);
+                                Some(at.rect(wordcraft_geom::Rect::new(x0.min(x1), lb.top, (x1 - x0).abs(), line.height)))
+                            });
+                            let mut n = Node::new(Role::Image);
+                            if !alt.trim().is_empty() {
+                                n.set_label(alt);
+                            }
+                            if let Some(r) = rect {
+                                n.set_bounds(bounds(r));
+                            }
+                            self.add(pid.with(("image", cl.start)), Some(pid), n);
+                        }
+                        ""
+                    }
+                    (ClKind::PageBreak | ClKind::ColumnBreak | ClKind::Marker, None) => "",
+                };
+                if text.is_empty() {
+                    continue;
+                }
+                let link = links.iter().find(|(r, _)| r.contains(&cl.start)).map(|(_, u)| u.clone());
+                if (link != lb.run.link || lb.run.lens.len() >= MAX_RUN) && !lb.run.lens.is_empty() {
+                    self.flush(&mut lb, line, at);
+                    if let Some(m) = lb.map.last_mut() {
+                        *m = (cl.start, lb.seg, 0);
+                    }
+                }
+                lb.run.link = link;
+                let (x0, x1) = (line.cl_left(k).unwrap_or(0.0), line.cl_right(k).unwrap_or(0.0));
+                push_char(&mut lb.run, text, x0.min(x1), (x1 - x0).abs());
+            }
+            if line.end == LineEnd::Para {
+                // The paragraph mark ends the run, as AccessKit expects of a paragraph's end.
+                if lb.run.link.is_some() && !lb.run.lens.is_empty() {
+                    self.flush(&mut lb, line, at);
+                }
+                if lb.run.lens.len() >= MAX_RUN {
+                    self.flush(&mut lb, line, at);
+                }
+                lb.run.link = None;
+                lb.map.push((para.text_len, lb.seg, lb.run.lens.len()));
+                let x = line.visual_end_x();
+                push_char(&mut lb.run, "\n", x, 0.0);
+            }
+            if !lb.run.lens.is_empty() || lb.prev.is_none() {
+                self.flush(&mut lb, line, at);
+            }
+            // Offsets that fell into an empty last segment point at the end of the last run.
+            let end = lb.prev;
+            let entries = self.offsets.entry(path.0.clone()).or_default();
+            for (off, seg, idx) in lb.map {
+                let (seg, idx) = if seg >= lb.seg { end.unwrap_or((seg, idx)) } else { (seg, idx) };
+                entries.push((off, pid.with(("run", li, seg)), idx));
+            }
+        }
+    }
+
+    /// Emit the run being gathered as a text run node (inside a link node when it is linked).
+    fn flush(&mut self, lb: &mut LineBuild, line: &Line, at: &LinePlace) {
+        let run = std::mem::take(&mut lb.run);
+        if run.lens.is_empty() && lb.prev.is_some() {
+            return;
+        }
+        let id = lb.pid.with(("run", lb.li, lb.seg));
+        let mut n = Node::new(Role::TextRun);
+        let x0 = run.xs.iter().map(|c| c.0).fold(f32::INFINITY, f32::min);
+        let x1 = run.xs.iter().map(|c| c.0 + c.1).fold(f32::NEG_INFINITY, f32::max);
+        let (x0, x1) = if x0.is_finite() && x1.is_finite() { (x0, x1) } else { (line.left, line.left) };
+        let r = at.rect(wordcraft_geom::Rect::new(x0, lb.top, (x1 - x0).max(0.0), line.height));
+        n.set_bounds(bounds(r));
+        let rtl = line.rtl || !line.vis.is_empty();
+        n.set_text_direction(if line.rtl { accesskit::TextDirection::RightToLeft } else { accesskit::TextDirection::LeftToRight });
+        if at.turn == TextDirection::Horizontal && !rtl {
+            n.set_character_positions(run.xs.iter().map(|c| (c.0 - x0) * at.scale).collect::<Vec<f32>>());
+            n.set_character_widths(run.xs.iter().map(|c| c.1 * at.scale).collect::<Vec<f32>>());
+        }
+        n.set_word_starts(word_starts(&run.text, &run.lens));
+        n.set_value(run.text);
+        n.set_character_lengths(run.lens.clone());
+        if let Some((pseg, _)) = lb.prev {
+            let pid = lb.pid.with(("run", lb.li, pseg));
+            n.set_previous_on_line(pid.accesskit_id());
+            if let Some(p) = self.node_mut(pid) {
+                p.set_next_on_line(id.accesskit_id());
+            }
+        }
+        let parent = match &run.link {
+            Some(url) => {
+                let lid = lb.pid.with(("link", lb.li, lb.seg));
+                let mut l = Node::new(Role::Link);
+                l.set_url(url.clone());
+                l.set_bounds(bounds(r));
+                self.add(lid, Some(lb.pid), l);
+                lid
+            }
+            None => lb.pid,
+        };
+        if self.add(id, Some(parent), n) {
+            lb.prev = Some((lb.seg, run.lens.len()));
+        }
+        lb.seg += 1;
+    }
+
+    /// The text position of byte `off` of the paragraph at `path`, when it is described.
+    fn position(&self, path: &Path, off: usize) -> Option<TextPosition> {
+        let entries = self.offsets.get(&path.0)?;
+        let i = entries.partition_point(|e| e.0 < off);
+        let (_, run, idx) = entries.get(i).or(entries.last())?;
+        self.index.contains_key(run).then(|| TextPosition { node: run.accesskit_id(), character_index: *idx })
+    }
+}
+
+/// A line being turned into runs.
+struct LineBuild {
+    pid: Id,
+    li: usize,
+    /// The segment (run) number being gathered.
+    seg: usize,
+    /// The last run emitted on this line and its length in characters.
+    prev: Option<(usize, usize)>,
+    /// The line's top in the frame of its `Placed::Lines`.
+    top: f32,
+    run: Run,
+    /// (byte offset, segment, character index) of each cluster.
+    map: Vec<(usize, usize, usize)>,
+}
+
+fn push_char(run: &mut Run, text: &str, x: f32, w: f32) {
+    // One character per cluster; a cluster longer than AccessKit's byte count keeps its first char.
+    let text = if text.len() > usize::from(u8::MAX) { text.get(..text.chars().next().map_or(0, char::len_utf8)).unwrap_or("") } else { text };
+    let Ok(len) = u8::try_from(text.len()) else { return };
+    if len == 0 {
+        return;
+    }
+    run.text.push_str(text);
+    run.lens.push(len);
+    let (x, w) = (if x.is_finite() { x } else { 0.0 }, if w.is_finite() { w } else { 0.0 });
+    run.xs.push((x, w));
+}
+
+/// Characters where a word starts (after one that isn't part of a word).
+fn word_starts(text: &str, lens: &[u8]) -> Vec<u8> {
+    let mut out = Vec::new();
+    let (mut at, mut after_gap) = (0usize, true);
+    for (i, len) in lens.iter().enumerate() {
+        let word = text.get(at..).and_then(|s| s.chars().next()).is_some_and(|c| c.is_alphanumeric() || c == '_');
+        if word && after_gap && i > 0 {
+            out.push(u8::try_from(i).unwrap_or(u8::MAX));
+        }
+        after_gap = !word;
+        at += usize::from(*len);
+    }
+    out
+}
+
+/// The paragraph's hyperlinked byte ranges and their targets.
+fn links(p: &wordcraft_doc::Paragraph) -> Vec<(std::ops::Range<usize>, String)> {
+    let mut out: Vec<(std::ops::Range<usize>, String)> = Vec::new();
+    let mut at = 0usize;
+    for r in &p.runs {
+        let end = at.saturating_add(r.len);
+        if let Some(url) = &r.props.link {
+            match out.last_mut() {
+                Some((range, u)) if range.end == at && u == url => range.end = end,
+                _ => out.push((at..end, url.clone())),
+            }
+        }
+        at = end;
+    }
+    out
+}
+
+fn bounds(r: Rect) -> accesskit::Rect {
+    accesskit::Rect { x0: r.min.x.into(), y0: r.min.y.into(), x1: r.max.x.into(), y1: r.max.y.into() }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::json;
+
+    /// #488: with AccessKit on, the canvas describes the document: a heading with its level, a
+    /// paragraph, a list item in a list, a table's rows and cells and a link, with the text in
+    /// text runs and the caret at its paragraph and character.
+    #[test]
+    fn the_canvas_describes_the_document_to_screen_readers() {
+        let mut app = crate::WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
+        for (cmd, p) in [
+            ("text.insert", json!({"text": "Title here"})),
+            ("para.style", json!({"style": "Heading1"})),
+            ("text.newParagraph", json!({})),
+            ("para.style", json!({"style": "Normal"})),
+            ("text.insert", json!({"text": "Read this "})),
+            ("insert.link", json!({"url": "https://example.com", "text": "link"})),
+            ("text.newParagraph", json!({})),
+            ("text.insert", json!({"text": "First item"})),
+            ("para.bullets", json!({})),
+            ("text.newParagraph", json!({})),
+            ("para.bullets", json!({})),
+            ("insert.table", json!({"rows": 2, "cols": 2})),
+            ("text.insert", json!({"text": "Cell A"})),
+        ] {
+            app.run(cmd, p).unwrap_or_else(|e| panic!("{cmd}: {e}"));
+        }
+        // The caret: in "Read this ", after "Read".
+        app.run("select.text", json!({"text": "Read"})).unwrap();
+        app.run("caret.right", json!({})).unwrap();
+        let caret = app.session.sel.focus.clone();
+        assert!(caret.path.0.len() == 1 && caret.off == 4, "{caret:?}");
+
+        let ctx = egui::Context::default();
+        ctx.enable_accesskit();
+        let mut update = None;
+        for i in 0..4 {
+            let input = egui::RawInput {
+                screen_rect: Some(Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1440.0, 900.0))),
+                time: Some(i as f64 * 0.1),
+                ..Default::default()
+            };
+            let mut out = ctx.run_ui(input, |ui| {
+                app.logic(ui.ctx());
+                app.ui(ui);
+            });
+            out.textures_delta.clear();
+            update = out.platform_output.accesskit_update.take();
+        }
+        let update = update.expect("AccessKit output");
+        let nodes: HashMap<NodeId, &Node> = update.nodes.iter().map(|(id, n)| (*id, n)).collect();
+
+        // A tree: every node has at most one parent.
+        let mut parents: HashMap<NodeId, usize> = HashMap::new();
+        for n in nodes.values() {
+            for c in n.children() {
+                *parents.entry(*c).or_default() += 1;
+            }
+        }
+        assert!(parents.values().all(|n| *n == 1), "a node with two parents");
+
+        let (doc_id, doc) = nodes.iter().find(|(_, n)| n.role() == Role::Document).expect("a document node");
+        // Text of a node's runs, depth first.
+        fn text(nodes: &HashMap<NodeId, &Node>, id: NodeId, out: &mut String) {
+            let Some(n) = nodes.get(&id) else { return };
+            if n.role() == Role::TextRun {
+                out.push_str(n.value().unwrap_or(""));
+            }
+            for c in n.children() {
+                text(nodes, *c, out);
+            }
+        }
+        let mut all = Vec::new();
+        fn walk(nodes: &HashMap<NodeId, &Node>, id: NodeId, depth: usize, out: &mut Vec<(NodeId, Role, usize)>) {
+            let Some(n) = nodes.get(&id) else { return };
+            out.push((id, n.role(), depth));
+            for c in n.children() {
+                walk(nodes, *c, depth + 1, out);
+            }
+        }
+        walk(&nodes, *doc_id, 0, &mut all);
+        let of = |role: Role| all.iter().filter(|(_, r, _)| *r == role).map(|(id, _, _)| *id).collect::<Vec<_>>();
+        let texts = |role: Role| {
+            of(role)
+                .into_iter()
+                .map(|id| {
+                    let mut s = String::new();
+                    text(&nodes, id, &mut s);
+                    s
+                })
+                .collect::<Vec<_>>()
+        };
+
+        let headings = of(Role::Heading);
+        assert_eq!(headings.len(), 1);
+        assert_eq!(nodes[&headings[0]].level(), Some(1));
+        assert_eq!(texts(Role::Heading), ["Title here\n"]);
+        assert!(texts(Role::Paragraph).contains(&"Read this link\n".to_string()), "{:?}", texts(Role::Paragraph));
+        assert_eq!(texts(Role::Link), ["link"]);
+        assert_eq!(nodes[&of(Role::Link)[0]].url(), Some("https://example.com"));
+        assert_eq!(of(Role::List).len(), 1, "one list");
+        assert_eq!(texts(Role::ListItem), ["First item\n"]);
+        assert_eq!(nodes[&of(Role::ListItem)[0]].level(), Some(1));
+        assert_eq!(of(Role::ListMarker).len(), 1, "the bullet");
+        assert_eq!(of(Role::Table).len(), 1);
+        assert_eq!(of(Role::Row).len(), 2);
+        assert_eq!(of(Role::Cell).len(), 4);
+        assert_eq!(texts(Role::Cell)[0], "Cell A\n");
+
+        // Text runs carry one length and one position per character.
+        for id in of(Role::TextRun) {
+            let n = nodes[&id];
+            let v = n.value().unwrap_or("");
+            assert_eq!(n.character_lengths().iter().map(|l| usize::from(*l)).sum::<usize>(), v.len(), "{v:?}");
+            if let Some(p) = n.character_positions() {
+                assert_eq!(p.len(), n.character_lengths().len());
+            }
+            assert!(n.bounds().is_some());
+        }
+
+        // The caret: the selection is on the document node, in "Read this "'s run, after "Read".
+        let s = doc.text_selection().expect("the caret");
+        assert_eq!(s.anchor, s.focus);
+        assert_eq!(s.focus.character_index, 4);
+        let run = nodes[&s.focus.node];
+        assert_eq!(run.role(), Role::TextRun);
+        assert_eq!(run.value(), Some("Read this "));
+    }
+
+    /// Hostile layouts and junk geometry don't panic and the tree stays bounded.
+    #[test]
+    fn junk_geometry_is_harmless() {
+        let doc = wordcraft_doc::Document::from_text(&"word ".repeat(4000));
+        let layout = wordcraft_layout::layout(&doc, &mut wordcraft_layout::LayoutCache::new(), &Default::default());
+        let n = layout.pages.len();
+        let rects = vec![Rect::from_min_size(egui::pos2(f32::NAN, 0.0), egui::vec2(f32::INFINITY, 1.0)); n];
+        let p = Pos::body(0, 1_000_000);
+        let t = build(&doc, &layout, Id::new("doc"), &rects, (0, n + 5), (&p, &p));
+        assert!(!t.nodes.is_empty() && t.nodes.len() <= MAX_NODES);
+        assert!(t.selection.is_some(), "an offset past the end lands at the end");
+        assert!(page_window(&rects, Rect::NOTHING).is_none());
+    }
+}
diff --git a/crates/ui-egui/src/a11y_pane.rs b/crates/ui-egui/src/a11y_pane.rs
new file mode 100644
index 0000000000..25d2c82c62
--- /dev/null
+++ b/crates/ui-egui/src/a11y_pane.rs
@@ -0,0 +1,158 @@
+//! The Accessibility pane (the checker's findings, grouped, each a jump and maybe a fix) and the
+//! Alt Text pane (the selected object's or table's alternative text).
+
+use egui::Ui;
+use serde_json::{Value, json};
+use wordcraft_doc::Pos;
+
+use crate::WordApp;
+use crate::theme::{regular, semibold};
+
+/// Review › Check Accessibility: the findings for the document as it is now.
+pub fn accessibility(app: &mut WordApp, ui: &mut Ui) {
+    if crate::panes::header(ui, "Accessibility") {
+        let _ = app.run("view.accessibilityPane", json!({"value": false}));
+        return;
+    }
+    let issues = issues(app, ui);
+    if issues.is_empty() {
+        ui.label(egui::RichText::new(tl!("No accessibility issues found.")).weak());
+        return;
+    }
+    let mut picked: Option<(Value, Option<Value>)> = None;
+    egui::ScrollArea::vertical().show(ui, |ui| {
+        for (kind, title) in [("error", "Errors ({n})"), ("warning", "Warnings ({n})"), ("tip", "Tips ({n})")] {
+            let group: Vec<&Value> = issues.iter().filter(|i| i["kind"] == kind).collect();
+            if group.is_empty() {
+                continue;
+            }
+            let heading = crate::i18n::fmt(tl!(title), &[("n", &group.len().to_string())]);
+            egui::CollapsingHeader::new(egui::RichText::new(heading).font(semibold(13.0))).id_salt(("a11y", kind)).default_open(true).show(
+                ui,
+                |ui| {
+                    for (k, i) in group.into_iter().enumerate() {
+                        ui.push_id(k, |ui| {
+                            let text = i["issue"].as_str().unwrap_or("");
+                            let r = ui.add(egui::Button::new(egui::RichText::new(text).font(regular(12.5))).frame(false).wrap());
+                            if let Some(fix) = i["fix"].as_str() {
+                                ui.label(egui::RichText::new(fix).small().weak());
+                            }
+                            if r.clicked() {
+                                picked = Some((i.clone(), None));
+                            }
+                            if let Some(a) = i.get("action").filter(|a| a.is_object())
+                                && let Some(label) = a["label"].as_str()
+                                && ui.small_button(tl!(label)).clicked()
+                            {
+                                picked = Some((i.clone(), Some(a.clone())));
+                            }
+                            ui.add_space(4.0);
+                        });
+                    }
+                },
+            );
+        }
+    });
+    if let Some((issue, action)) = picked {
+        go_to(app, &issue);
+        if let Some(a) = action
+            && let Some(cmd) = a["command"].as_str()
+        {
+            let _ = app.run(cmd, a.get("params").cloned().unwrap_or_else(|| json!({})));
+        }
+    }
+}
+
+/// The checker's findings, kept until the document changes.
+fn issues(app: &mut WordApp, ui: &Ui) -> Vec<Value> {
+    let key = egui::Id::new("a11y_issues");
+    let stamp = (app.session.document_id(), app.session.rev());
+    if let Some((s, v)) = ui.data(|d| d.get_temp::<((u64, u64), Vec<Value>)>(key))
+        && s == stamp
+    {
+        return v;
+    }
+    let v = wordcraft_engine::cmd::accessibility::check(&app.session.doc);
+    ui.data_mut(|d| d.insert_temp(key, (stamp, v.clone())));
+    v
+}
+
+/// Select the object an issue is about, or put the caret where it is.
+fn go_to(app: &mut WordApp, issue: &Value) {
+    if let Some(sel) = issue.get("select").filter(|s| s.is_object()) {
+        let _ = app.run("select.range", sel.clone());
+    } else if let Some(pos) = issue.get("pos").filter(|p| p.is_object()) {
+        let _ = app.run("caret.set", json!({"pos": pos}));
+    }
+    app.canvas.want_focus = true;
+}
+
+/// Alt Text: the selected picture's, shape's, chart's or group's description and decorative mark,
+/// or the title and description of the table the caret is in.
+pub fn alt_text(app: &mut WordApp, ui: &mut Ui) {
+    if crate::panes::header(ui, "Alt Text") {
+        let _ = app.run("view.altTextPane", json!({"value": false}));
+        return;
+    }
+    if let Some((pos, obj)) = wordcraft_engine::cmd::objects::selected(&app.session) {
+        let decorative = obj.is_decorative();
+        ui.label(egui::RichText::new(tl!("Describe what this object shows, for people who can't see it.")).weak());
+        ui.add_space(4.0);
+        if let Some(text) = draft_box(ui, ("alt_obj", &pos), obj.alt_text(), !decorative, true)
+            && still_selected(app, &pos)
+        {
+            let _ = app.run("object.altText", json!({"text": text}));
+        }
+        ui.add_space(6.0);
+        let mut d = decorative;
+        if ui.checkbox(&mut d, tl!("Mark as decorative")).changed() {
+            let _ = app.run("object.altText", json!({"decorative": d}));
+        }
+        ui.label(egui::RichText::new(tl!("Decorative objects only add visual interest: screen readers skip them.")).small().weak());
+        return;
+    }
+    let focus = app.session.sel.focus.clone();
+    let table = focus
+        .path
+        .cell()
+        .and_then(|(tp, _, _)| app.session.doc.table(focus.story, &tp).map(|t| (tp, t.props.caption.clone(), t.props.description.clone())));
+    if let Some((tp, caption, description)) = table {
+        ui.label(egui::RichText::new(tl!("Describe what this table shows, for people who can't see it.")).weak());
+        ui.add_space(4.0);
+        ui.label(tl!("Title:"));
+        if let Some(t) = draft_box(ui, ("alt_table_title", &tp), caption.as_deref().unwrap_or(""), true, false) {
+            let _ = app.run("table.altText", json!({"title": t}));
+        }
+        ui.add_space(4.0);
+        ui.label(tl!("Description:"));
+        if let Some(t) = draft_box(ui, ("alt_table_text", &tp), description.as_deref().unwrap_or(""), true, true) {
+            let _ = app.run("table.altText", json!({"text": t}));
+        }
+        return;
+    }
+    ui.label(egui::RichText::new(tl!("Select a picture, shape, chart or table to describe it.")).weak());
+}
+
+fn still_selected(app: &WordApp, pos: &Pos) -> bool {
+    wordcraft_engine::cmd::objects::selected(&app.session).is_some_and(|(p, _)| &p == pos)
+}
+
+/// A text box editing `current`; the draft lives in egui memory while it has focus (frame-local
+/// buffers lose keystrokes). Returns the new text when editing ends with a change.
+fn draft_box(ui: &mut Ui, key: impl std::hash::Hash + std::fmt::Debug, current: &str, enabled: bool, multiline: bool) -> Option<String> {
+    let key = egui::Id::new(key);
+    let mut text = ui.data(|d| d.get_temp::<String>(key)).unwrap_or_else(|| current.to_string());
+    let edit = if multiline { egui::TextEdit::multiline(&mut text).desired_rows(5) } else { egui::TextEdit::singleline(&mut text) };
+    let r = ui.add_enabled(enabled, edit.desired_width(f32::INFINITY));
+    if r.changed() {
+        ui.data_mut(|d| d.insert_temp(key, text.clone()));
+    }
+    if r.lost_focus() {
+        ui.data_mut(|d| d.remove::<String>(key));
+        return (text != current).then_some(text);
+    }
+    if !r.has_focus() {
+        ui.data_mut(|d| d.remove::<String>(key));
+    }
+    None
+}
diff --git a/crates/ui-egui/src/backstage.rs b/crates/ui-egui/src/backstage.rs
index 65da760507..0e2970ce89 100644
--- a/crates/ui-egui/src/backstage.rs
+++ b/crates/ui-egui/src/backstage.rs
@@ -51,7 +51,8 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
                 );
                 resp
             };
-            if back.clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+            // Escape in the built-in file browser closes only the browser.
+            if back.clicked() || (!app.file_dialog_open() && ui.input(|i| i.key_pressed(egui::Key::Escape))) {
                 app.ui.backstage = false;
                 app.canvas.want_focus = true;
             }
@@ -110,7 +111,7 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
             "open" => open_page(app, ui),
             "info" => info_page(app, ui),
             "print" | "export" => export_page(app, ui),
-            "options" => options_page(app, ui),
+            "options" => crate::options::page(app, ui),
             _ => home_page(app, ui),
         });
     });
@@ -240,7 +241,7 @@ fn open_list(app: &mut WordApp, ui: &mut Ui) {
     if app.ui.recent.is_empty() {
         ui.label(egui::RichText::new(tl!("Documents you open will show up here.")).color(t.text_dim));
     }
-    for p in app.ui.recent.clone() {
+    for p in app.ui.recent.iter().take(app.ui.recent_shown()).cloned().collect::<Vec<_>>() {
         let name = std::path::Path::new(&p).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or(p.clone());
         let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width().min(700.0), 40.0), Sense::click());
         if resp.hovered() {
@@ -262,6 +263,16 @@ fn open_page(app: &mut WordApp, ui: &mut Ui) {
     if ui.button(egui::RichText::new(tl!("Browse…")).font(medium(14.0))).clicked() {
         let _ = app.run("ui.openFileDialog", json!({}));
     }
+    // Linux and the BSDs (#576): the system dialog needs a file chooser portal or zenity; when it
+    // doesn't show up, WordCraft's own browser is always one click away.
+    #[cfg(all(unix, not(target_os = "macos"), not(target_arch = "wasm32")))]
+    if ui
+        .button(egui::RichText::new(tl!("Browse in WordCraft…")).font(medium(14.0)))
+        .on_hover_text(tl!("Open a file with WordCraft's own browser when the system file dialog doesn't appear."))
+        .clicked()
+    {
+        let _ = app.run("ui.fileBrowser", json!({}));
+    }
     ui.add_space(18.0);
     open_list(app, ui);
 }
@@ -331,161 +342,27 @@ fn info_page(app: &mut WordApp, ui: &mut Ui) {
 }
 
 fn export_page(app: &mut WordApp, ui: &mut Ui) {
-    let is_print = app.ui.backstage_page == "print";
-    heading(ui, if is_print { "Print" } else { "Export" });
-    if is_print && app.services.print.is_some() {
-        ui.label(tl!("Send the document straight to the system print dialog, or save a copy in another format below."));
-        ui.add_space(12.0);
-        if ui.add(egui::Button::new(egui::RichText::new(tl!("Print")).font(medium(13.5))).min_size(vec2(320.0, 34.0))).clicked() {
-            let _ = app.run("ui.print", json!({}));
+    if app.ui.backstage_page == "print" {
+        heading(ui, "Print");
+        // Print Markup (a print setting, as in Word): the comments beside each page.
+        let mut markup = app.session.prefs.print_markup;
+        if ui
+            .checkbox(&mut markup, tl!("Print Markup"))
+            .on_hover_text(tl!(
+                "Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text."
+            ))
+            .changed()
+        {
+            let _ = app.run("file.printMarkup", json!({"value": markup}));
         }
         ui.add_space(12.0);
-        ui.separator();
-        ui.add_space(12.0);
-        ui.label(tl!("Or save a copy in another format:"));
-    } else {
-        ui.label(tl!("Save a copy in another format. Printing goes through a PDF you can print from any viewer."));
+        crate::print_page::show(app, ui);
+        return;
     }
+    heading(ui, "Export");
+    ui.label(tl!("Save a copy in another format. Printing goes through a PDF you can print from any viewer."));
     ui.add_space(12.0);
-    for (label, ext) in [
-        ("PDF document (*.pdf)", "pdf"),
-        ("Word document (*.docx)", "docx"),
-        ("OpenDocument Text (*.odt)", "odt"),
-        ("Rich Text Format (*.rtf)", "rtf"),
-        ("Web page (*.html)", "html"),
-        ("Markdown (*.md)", "md"),
-        ("LaTeX (*.tex)", "tex"),
-        ("Plain text (*.txt)", "txt"),
-        ("Page image (*.png)", "png"),
-    ] {
-        if ui.add(egui::Button::new(egui::RichText::new(tl!(label)).font(medium(13.5))).min_size(vec2(320.0, 34.0))).clicked() {
-            app.export_dialog(ext);
-        }
-        ui.add_space(4.0);
-    }
-}
-
-fn options_page(app: &mut WordApp, ui: &mut Ui) {
-    heading(ui, "Options");
-    ui.label(egui::RichText::new(tl!("General")).font(semibold(15.0)));
-    language_picker(app, ui);
-    ui.horizontal(|ui| {
-        ui.label(tl!("User name:"));
-        let mut n = app.session.author.clone();
-        if ui.text_edit_singleline(&mut n).changed() {
-            app.session.author = n;
-        }
-    });
-    theme_picker(app, ui);
-    interface_size_picker(app, ui);
-    // The browser can't write to the user's files, so AutoSave can't be turned on there (#176).
-    let browser = app.autosave_block() == Some(crate::AutoSaveBlock::Browser);
-    let mut autosave = app.autosave && !browser;
-    let r = ui.add_enabled(!browser, egui::Checkbox::new(&mut autosave, tl!("AutoSave documents you have saved in WordCraft")));
-    if browser {
-        r.on_disabled_hover_text(crate::AutoSaveBlock::Browser.reason());
-    } else if r.changed() {
-        app.autosave = autosave;
-        app.session.autosave = autosave;
-    }
-    let mut dark_page = app.session.view.dark_mode;
-    if ui
-        .checkbox(&mut dark_page, tl!("Dark page (white text on black)"))
-        .on_hover_text(tl!("Show documents with their colours inverted, like View › Switch Modes. Saving, printing and PDFs are unchanged."))
-        .changed()
-    {
-        let _ = app.run("view.darkMode", json!({"value": dark_page}));
-    }
-    ui.checkbox(&mut app.ui.show_discord, tl!("Show the community button in the title bar"));
-    ui.add_space(10.0);
-    ui.label(egui::RichText::new(tl!("Display")).font(semibold(15.0)));
-    let mut marks = app.session.view.marks;
-    if ui.checkbox(&mut marks, tl!("Show all formatting marks")).changed() {
-        let _ = app.run("view.marks", json!({"value": marks}));
-    }
-    let mut ruler = app.session.view.ruler;
-    if ui.checkbox(&mut ruler, tl!("Show rulers")).changed() {
-        let _ = app.run("view.ruler", json!({"value": ruler}));
-    }
-    ui.add_space(10.0);
-    ui.label(egui::RichText::new(tl!("Customize")).font(semibold(15.0)));
-    ui.horizontal(|ui| {
-        ui.label(tl!("Keyboard shortcuts:"));
-        if ui.button(tl!("Customize…")).clicked() {
-            let _ = app.run("tools.customizeKeyboard", json!({}));
-        }
-    });
-    ui.horizontal(|ui| {
-        ui.label(tl!("Ribbon and Quick Access Toolbar:"));
-        if ui.button(tl!("Customize…")).clicked() {
-            let _ = app.run("tools.customizeRibbon", json!({}));
-        }
-    });
-    ui.add_space(10.0);
-    ui.label(egui::RichText::new(tl!("Agents")).font(semibold(15.0)));
-    ui.label(tl!("Every command is available to scripts and AI agents: run `wordcraft-cli mcp` for an MCP server, or start the app with `--control <port>` for the JSON control channel."));
-}
-
-/// File ▸ Options ▸ Interface theme: Light, Dark, or follow the system's appearance (#115).
-fn theme_picker(app: &mut WordApp, ui: &mut Ui) {
-    use crate::theme::Appearance;
-    ui.horizontal(|ui| {
-        ui.label(tl!("Interface theme:"));
-        egui::ComboBox::from_id_salt("interface_theme").selected_text(tl!(app.ui.theme.label())).width(220.0).show_ui(ui, |ui| {
-            for a in Appearance::ALL {
-                if ui.selectable_label(app.ui.theme == a, tl!(a.label())).clicked() {
-                    let _ = app.run("ui.theme", json!({"value": a.code()}));
-                }
-            }
-        });
-    });
-}
-
-/// File ▸ Options ▸ Interface size: 80–200 %, on top of the system's display scale (#475).
-fn interface_size_picker(app: &mut WordApp, ui: &mut Ui) {
-    use crate::theme::InterfaceSize;
-    let current = app.ui.interface_size.percent();
-    ui.horizontal(|ui| {
-        ui.label(tl!("Interface size:"));
-        egui::ComboBox::from_id_salt("interface_size").selected_text(format!("{current}%")).width(220.0).show_ui(ui, |ui| {
-            for pct in InterfaceSize::PRESETS {
-                if ui.selectable_label(current == pct, format!("{pct}%")).clicked() {
-                    let _ = app.run("ui.interfaceSize", json!({"percent": pct}));
-                }
-            }
-        });
-    });
-    ui.label(
-        egui::RichText::new(tl!(
-            "Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate."
-        ))
-        .small()
-        .weak(),
-    );
-}
-
-/// File ▸ Options ▸ Interface language: follow the system (the default) or pick one (#8).
-fn language_picker(app: &mut WordApp, ui: &mut Ui) {
-    use crate::i18n::{AUTO, Lang};
-    // The language names are in their own scripts: fonts for them load from the next frame.
-    app.want_system_cjk = true;
-    let system = crate::i18n::system_lang();
-    let auto_label = crate::i18n::fmt(tl!("Automatic ({language})"), &[("language", system.name())]);
-    let current = if app.ui.language == AUTO { auto_label.clone() } else { Lang::from_pref(&app.ui.language).name().to_string() };
-    ui.horizontal(|ui| {
-        ui.label(tl!("Interface language:"));
-        egui::ComboBox::from_id_salt("interface_language").selected_text(current).width(220.0).show_ui(ui, |ui| {
-            if ui.selectable_label(app.ui.language == AUTO, auto_label.as_str()).clicked() {
-                let _ = app.run("ui.language", json!({"value": AUTO}));
-            }
-            for lang in Lang::all() {
-                if ui.selectable_label(app.ui.language == lang.code(), lang.name()).clicked() {
-                    let _ = app.run("ui.language", json!({"value": lang.code()}));
-                }
-            }
-        });
-    });
-    ui.label(egui::RichText::new(tl!("Automatic follows your system's language. Menus and commands change; your documents don't.")).small().weak());
+    crate::print_page::export_formats(app, ui);
 }
 
 #[cfg(test)]
diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rs
index b42edb998c..b01f8797fb 100644
--- a/crates/ui-egui/src/canvas.rs
+++ b/crates/ui-egui/src/canvas.rs
@@ -18,6 +18,15 @@ pub const PX_PER_PT: f32 = 96.0 / 72.0;
 const GAP: f32 = 18.0;
 const RULER: f32 = 22.0;
 
+/// Drag-select auto-scroll (#688): the pointer within this many points of the viewport's edge
+/// starts scrolling, like Word.
+const EDGE_MARGIN: f32 = 32.0;
+/// Auto-scroll speed (points/s) at the margin's inner boundary and at (or past) the edge.
+const EDGE_SPEED_MIN: f32 = 45.0;
+const EDGE_SPEED_MAX: f32 = 720.0;
+/// Longest frame time trusted for auto-scroll (a stall shouldn't jump the page).
+const EDGE_MAX_DT: f32 = 0.1;
+
 pub struct CanvasState {
     textures: HashMap<usize, (u64, TextureHandle)>,
     pub scroll_to_caret: bool,
@@ -25,6 +34,12 @@ pub struct CanvasState {
     dragging: bool,
     /// Alt+drag: where the column (block) selection started (page, x, y) and its last end.
     column_drag: Option<((usize, f32, f32), (usize, f32, f32))>,
+    /// The last primary press on the page (time, screen point, clicks in a row), to count
+    /// double- and triple-presses as they go down (egui reports them on release).
+    last_press: Option<(f64, Pos2, u8)>,
+    /// A drag after a double-click, triple-click or Ctrl/⌘+click: the unit it extends by, the
+    /// unit first selected, and the last position the pointer hit.
+    unit_drag: Option<UnitDrag>,
     pub last_highlight: String,
     pub last_font_color: String,
     pub last_shading: String,
@@ -37,6 +52,8 @@ pub struct CanvasState {
     pub focused: bool,
     pub render_ms: f64,
     pub ime_preedit: String,
+    /// Document faces added to the interface fonts to draw the input method's composition (#565).
+    pub(crate) ime_faces: Vec<std::sync::Arc<wordcraft_fonts::FontFace>>,
     pub want_focus: bool,
     pub context_issue: Option<serde_json::Value>,
     pub context_synonyms: Option<serde_json::Value>,
@@ -50,11 +67,16 @@ pub struct CanvasState {
     pub(crate) ink: Option<crate::ink::InkDrag>,
     /// The eraser is down: whether it has erased anything in this drag yet.
     pub(crate) erasing: Option<bool>,
+    /// The lasso being drawn or dragged, and Ink Replay (Draw tab).
+    pub(crate) ink_ui: crate::ink::InkUi,
     /// Wheel/touchpad scrolling (smooth notches, touchpad momentum).
     pub(crate) wheel: crate::scroll::CanvasScroll,
     /// The scroll offset and its maximum at the end of last frame.
     pub(crate) scroll_offset: egui::Vec2,
     scroll_max: egui::Vec2,
+    /// The viewport (the content's visible rect on screen) at the end of last frame; the
+    /// drag-select edge auto-scroll decides this frame's scroll from it (#688).
+    pub(crate) viewport: Option<egui::Rect>,
     /// Pages per row last frame; when it changes the caret's page is scrolled back into view.
     pub cols: usize,
     /// The comment whose balloon is selected (its text is editable in place, like Word's).
@@ -73,11 +95,15 @@ pub struct CanvasState {
     pub table_tool: Option<crate::table_pen::TableTool>,
     /// The Draw Table stroke (or eraser press) in progress.
     pub(crate) table_stroke: Option<crate::table_pen::PenStroke>,
+    /// A table border or the table's resize handle being dragged (`table_resize`).
+    pub(crate) table_resize: Option<crate::table_resize::ResizeDrag>,
     /// The last key ran an Alt shortcut: the text its key sends (it may arrive a frame later)
     /// isn't typed. The next key press clears it.
     pub(crate) swallow_text: bool,
     /// Create Link is waiting for a click on the text box to link to: the linking box's object.
     pub(crate) link_from: Option<wordcraft_doc::Pos>,
+    /// What screen readers were last told about the document (#488).
+    pub(crate) a11y: crate::a11y::A11yCache,
 }
 
 impl CanvasState {
@@ -95,6 +121,8 @@ impl Default for CanvasState {
             caret_visible_since: 0.0,
             dragging: false,
             column_drag: None,
+            last_press: None,
+            unit_drag: None,
             last_highlight: "yellow".into(),
             last_font_color: "C00000".into(),
             last_shading: "FFF2CC".into(),
@@ -105,12 +133,14 @@ impl Default for CanvasState {
             focused: false,
             render_ms: 0.0,
             ime_preedit: String::new(),
+            ime_faces: Vec::new(),
             want_focus: true,
             context_issue: None,
             context_synonyms: None,
             obj_drag: None,
             ink: None,
             erasing: None,
+            ink_ui: Default::default(),
             context_menu_open: false,
             mini_anchor: None,
             pasted: false,
@@ -118,6 +148,7 @@ impl Default for CanvasState {
             wheel: Default::default(),
             scroll_offset: egui::Vec2::ZERO,
             scroll_max: egui::Vec2::ZERO,
+            viewport: None,
             cols: 1,
             balloon: None,
             balloon_focus: false,
@@ -126,11 +157,32 @@ impl Default for CanvasState {
             balloon_rects: Vec::new(),
             table_tool: None,
             table_stroke: None,
+            table_resize: None,
             link_from: None,
+            a11y: Default::default(),
         }
     }
 }
 
+/// See [`CanvasState::unit_drag`].
+struct UnitDrag {
+    unit: &'static str,
+    /// Clicks in a row that made it (2 or 3; 1 for Ctrl/⌘+click).
+    clicks: u8,
+    start: Pos,
+    end: Pos,
+    last: Pos,
+}
+
+/// Clicks in a row for a press at `at` (time `now`) after `last`: within the double-click
+/// delay and distance it counts up to 3 (a triple-click), otherwise it starts again at 1.
+fn press_count(last: Option<(f64, Pos2, u8)>, now: f64, at: Pos2, delay: f64, dist: f32) -> u8 {
+    match last {
+        Some((t, p, n)) if now - t >= 0.0 && now - t < delay && p.distance(at) <= dist => n.saturating_add(1).min(3),
+        _ => 1,
+    }
+}
+
 impl CanvasState {
     /// True while a mouse drag-select is in progress (the mini toolbar waits for mouse-up).
     pub fn drag_selecting(&self) -> bool {
@@ -145,21 +197,75 @@ pub struct Geometry {
     pub scale: f32,
     /// Pages per row.
     pub cols: usize,
+    /// Per page, the vertical range (pixels from the page rect's top) that is on screen. The
+    /// whole page, except with Hide White Space, which cuts the margins between pages.
+    pub bands: Vec<(f32, f32)>,
 }
 
-/// Width of the markup area beside each page for comment balloons (points), or 0.
+/// Room kept above the first line and below the last line of a page when white space is hidden (points).
+const WHITE_SPACE_PAD: f32 = 6.0;
+/// The line drawn between two pages when white space is hidden (pixels).
+const SEAM: f32 = 1.0;
+
+/// Hide White Space: stack single-column pages (`rects`, full pages) so that only each page's
+/// text area (`bodies`: top and bottom of the body in points, plus a little room) shows, with a
+/// [`SEAM`] between pages. The first page keeps its top and the last its bottom. Rects keep the
+/// full page size, so page coordinates still map as `(p - rect.min) / scale`; neighbouring rects
+/// overlap in the hidden margins. Returns the moved rects, the visible band of each, and the
+/// content height.
+fn collapse_white_space(rects: &[Rect], bodies: &[(f32, f32)], scale: f32, avail_h: f32) -> (Vec<Rect>, Vec<(f32, f32)>, f32) {
+    let n = rects.len();
+    let scale = if scale.is_finite() { scale.clamp(0.01, 10.0) } else { PX_PER_PT };
+    let avail_h = if avail_h.is_finite() { avail_h } else { 0.0 };
+    let mut out = Vec::with_capacity(n);
+    let mut bands = Vec::with_capacity(n);
+    let Some(first) = rects.first() else { return (out, bands, avail_h) };
+    let mut cursor = first.min.y;
+    for (i, r) in rects.iter().enumerate() {
+        let h = if r.height().is_finite() { r.height().max(0.0) } else { 0.0 };
+        let (bt, bb) = bodies.get(i).copied().unwrap_or((0.0, h));
+        let fin = |v: f32, d: f32| if v.is_finite() { v } else { d };
+        let top = if i == 0 { 0.0 } else { (fin(bt, 0.0) * scale - WHITE_SPACE_PAD * scale).clamp(0.0, h) };
+        let bot = if i + 1 == n { h } else { (fin(bb, 0.0) * scale + WHITE_SPACE_PAD * scale).clamp(top, h) };
+        let y = cursor - top;
+        out.push(Rect::from_min_size(pos2(r.min.x, y), r.size()));
+        bands.push((top, bot));
+        cursor = y + bot + SEAM;
+    }
+    (out, bands, (cursor - SEAM + GAP).max(avail_h))
+}
+
+/// True when any page is cut to a band (white space is hidden).
+fn white_space_hidden(rects: &[Rect], bands: &[(f32, f32)]) -> bool {
+    rects.iter().zip(bands).any(|(r, b)| b.0 > 0.5 || b.1 < r.height() - 0.5)
+}
+
+/// True when a double-click at `p` is on the space between two pages (or on the seam when white
+/// space is hidden): Word's way to toggle Hide White Space.
+fn on_page_gap(rects: &[Rect], bands: &[(f32, f32)], p: Pos2) -> bool {
+    let hidden = white_space_hidden(rects, bands);
+    rects.windows(2).enumerate().any(|(i, w)| {
+        let (a, b) = (w[0], w[1]);
+        let in_x = p.x >= a.min.x.min(b.min.x) && p.x <= a.max.x.max(b.max.x);
+        let (y0, y1) = match bands.get(i) {
+            Some(&(_, bot)) if hidden => (a.min.y + bot - 3.0, a.min.y + bot + SEAM + 3.0),
+            _ => (a.max.y, b.min.y),
+        };
+        in_x && p.y >= y0 && p.y <= y1
+    })
+}
+
+/// Width of the markup area beside each page for comment and revision balloons (points), or 0.
 pub fn markup_width(app: &WordApp) -> f32 {
-    let v = &app.session.view;
-    // Word shows comments either in balloons (contextual) or in the Comments pane (list).
-    let on = v.show_markup && !v.comments_pane && !v.read_mode && !v.multi_page && v.mode == wordcraft_layout::ViewMode::Print;
-    // Track Changes Options: comments and formatting hidden, or every revision inline, leave
-    // no markup area.
-    let m = &app.session.prefs.markup;
-    let on = on && m.balloons != wordcraft_layout::display::BalloonMode::Inline;
-    let comments = m.comments && !app.session.doc.comments.is_empty();
-    let formats = m.formatting && wordcraft_engine::cmd::review::has_format_changes(&app.session.doc);
-    let moves = m.insertions_deletions && wordcraft_engine::cmd::moves::has_moves(&app.session.doc);
-    if on && (comments || formats || moves) { 216.0 } else { 0.0 }
+    // Word shows comments either in balloons (contextual) or in the Comments pane (list); Track
+    // Changes Options can put every revision inline (`Session::balloons_shown`).
+    let s = &app.session;
+    let m = &s.prefs.markup;
+    let comments = m.comments && !s.doc.comments.is_empty();
+    let formats = m.formatting && wordcraft_engine::cmd::review::has_format_changes(&s.doc);
+    let moves = m.insertions_deletions && wordcraft_engine::cmd::moves::has_moves(&s.doc);
+    let deletions = s.revisions_in_balloons() && wordcraft_engine::cmd::review::has_deletions(&s.doc);
+    if s.balloons_shown() && (comments || formats || moves || deletions) { 216.0 } else { 0.0 }
 }
 
 /// A page dimension (points) safe to lay out: finite, at least 1 pt, at most `cap`.
@@ -245,8 +351,16 @@ pub fn geometry(app: &WordApp, l: &DocLayout, avail: egui::Vec2) -> Geometry {
     };
     let cols = if v.read_mode { 2 } else { columns_for(avail.x, maxw * scale, l.pages.len(), min_cols, auto) };
     let sizes: Vec<(f32, f32)> = l.pages.iter().map(|p| (p.w, p.h)).collect();
-    let (rects, size) = place_pages(&sizes, markup, scale, cols, avail);
-    Geometry { rects, size, scale, cols }
+    let (mut rects, mut size) = place_pages(&sizes, markup, scale, cols, avail);
+    let mut bands: Vec<(f32, f32)> = rects.iter().map(|r| (0.0, r.height())).collect();
+    let editing_part = matches!(app.session.sel.focus.story, StoryRef::Part(_));
+    if v.hide_white_space && v.mode == wordcraft_layout::ViewMode::Print && !v.read_mode && cols == 1 && !editing_part && rects.len() > 1 {
+        let bodies: Vec<(f32, f32)> = l.pages.iter().map(|p| (p.body.y, p.body.bottom())).collect();
+        let (r, b, h) = collapse_white_space(&rects, &bodies, scale, avail.y);
+        (rects, bands) = (r, b);
+        size.y = h;
+    }
+    Geometry { rects, size, scale, cols, bands }
 }
 
 /// While a fit mode (Page Width, One Page, Multiple Pages) sizes the page, keep the session's zoom
@@ -266,7 +380,7 @@ fn page_key(app: &WordApp, page: &Page, scale_px: f32, dim_body: bool) -> u64 {
     let mut h = std::collections::hash_map::DefaultHasher::new();
     scale_px.to_bits().hash(&mut h);
     let v = &app.session.view;
-    (v.marks, v.show_markup, v.dark_mode, wordcraft_render::DARK_PAPER, v.hide_ink).hash(&mut h);
+    (v.marks, app.session.prefs.marks, v.show_markup, v.dark_mode, wordcraft_render::DARK_PAPER, v.hide_ink, v.draw.replay).hash(&mut h);
     app.session.prefs.markup.hash(&mut h);
     dim_body.hash(&mut h);
     format!("{:?}{:?}", app.session.doc.settings.page_color, app.session.doc.settings.watermark).hash(&mut h);
@@ -281,8 +395,8 @@ fn page_key(app: &WordApp, page: &Page, scale_px: f32, dim_body: bool) -> u64 {
                 Placed::Fill { rect, color } => format!("{rect:?}{color:?}").hash(&mut h),
                 Placed::Rule { x0, y0, x1, y1, border } => format!("{x0}{y0}{x1}{y1}{border:?}").hash(&mut h),
                 Placed::Image { rect, media, spin, .. } => format!("{rect:?}{media}{spin:?}").hash(&mut h),
-                Placed::Shape { rect, kind, fill, stroke, stroke_width, effects, freeform, spin } => {
-                    format!("{rect:?}{kind:?}{fill:?}{stroke:?}{stroke_width}{effects:?}{spin:?}").hash(&mut h);
+                Placed::Shape { rect, kind, fill, stroke, stroke_width, effects, freeform, spin, extra } => {
+                    format!("{rect:?}{kind:?}{fill:?}{stroke:?}{stroke_width}{effects:?}{spin:?}{extra:?}").hash(&mut h);
                     freeform.as_ref().map(|f| std::sync::Arc::as_ptr(f) as usize).hash(&mut h);
                 }
                 Placed::Graphic { rect, graphic, spin, .. } => {
@@ -350,6 +464,7 @@ fn drawing_grid_step(spacing: f32, scale: f32) -> f32 {
 
 pub fn show(app: &mut WordApp, ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
+    crate::ink::replay_tick(app, ui.ctx());
     let layout = app.session.layout();
     // View › Switch Modes: dark paper, inverted document colours, a white caret.
     let dark_page = app.session.view.dark_mode;
@@ -367,12 +482,21 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
     app.canvas.canvas_rect = Some(area);
     // Ctrl/⌘ + wheel (and trackpad pinch) zooms the document, like Word. egui reports both as a
     // zoom factor and doesn't scroll for them. Start from the shown scale so fit modes zoom too.
-    let zoom_delta = ui.input(|i| i.zoom_delta());
+    // With animation effects off the wheel zooms in whole steps, each at once.
+    let animate = app.animations_on();
+    let opts = ui.ctx().options(|o| o.input_options);
+    let zoom_delta = ui.input(|i| app.canvas.wheel.zoom(i, &opts, animate));
     if (zoom_delta - 1.0).abs() > 1e-3 && ui.rect_contains_pointer(area) {
         let pct = (app.canvas.scale / PX_PER_PT * zoom_delta * 100.0).clamp(10.0, 500.0);
         let _ = app.run("view.zoom", json!({"value": pct}));
     }
     let geo = geometry(app, &layout, area.size() - vec2(14.0, 0.0));
+    // The status bar's zoom readout and slider were laid out before this, from the last frame's
+    // scale: after a zoom change draw again at once, so they follow in the next frame rather than
+    // whenever something else next repaints (the caret's blink).
+    if (geo.scale - app.canvas.scale).abs() > 1e-6 {
+        ui.ctx().request_repaint();
+    }
     app.canvas.scale = geo.scale;
     sync_fit_zoom(app, geo.scale);
     // Zooming or resizing reflowed the pages into a different number of columns: the caret's page
@@ -402,21 +526,40 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
     let mut origin = area.min;
     let mut ui_area = ui.new_child(egui::UiBuilder::new().max_rect(area));
     // The canvas scrolls itself on wheel/touchpad input (crate::scroll): touchpads 1:1 with
-    // momentum, wheel notches eased in. Applied before drawing, so it shows this frame.
+    // momentum, wheel notches eased in (or all at once with animation effects off). Applied
+    // before drawing, so it shows this frame.
     let hovered = ui.rect_contains_pointer(area) && ui.ctx().dragged_id().is_none();
     let notch = crate::scroll::notch_px(app.canvas.scale / PX_PER_PT);
-    let opts = ui.ctx().options(|o| o.input_options);
-    let delta = ui.input(|i| app.canvas.wheel.frame(i, &opts, hovered, notch, area.height()));
+    let wheel_delta = ui.input(|i| app.canvas.wheel.frame(i, &opts, hovered, notch, area.height(), animate));
+    // Dragging a selection near the viewport's edge scrolls on (#688): from a crawl at the margin
+    // to full speed at the edge, through the same offset the wheel writes.
+    let (down, pointer, dt) = ui.input(|i| (i.pointer.primary_down(), i.pointer.latest_pos(), i.stable_dt));
+    let auto_delta = if app.canvas.drag_selecting()
+        && down
+        && let Some(vp) = app.canvas.viewport
+        && let Some(p) = pointer
+    {
+        vec2(edge_scroll(p.x, vp.min.x, vp.max.x, dt), edge_scroll(p.y, vp.min.y, vp.max.y, dt))
+    } else {
+        egui::Vec2::ZERO
+    };
+    let delta = wheel_delta + auto_delta;
     let mut scroll_area = egui::ScrollArea::both()
         .id_salt("canvas_scroll")
         .auto_shrink([false, false])
+        // Bringing the caret into view glides there, or jumps with animation effects off.
+        .animated(animate)
         .scroll_source(egui::scroll_area::ScrollSource { mouse_wheel: false, ..Default::default() });
     if delta != egui::Vec2::ZERO {
         let before = app.canvas.scroll_offset;
-        let after = (before - delta).clamp(egui::Vec2::ZERO, app.canvas.scroll_max);
-        if after == before {
+        let after = clamped_scroll(before, delta, app.canvas.scroll_max);
+        if after == before && wheel_delta != egui::Vec2::ZERO {
             app.canvas.wheel.hit_edge();
         }
+        if auto_delta != egui::Vec2::ZERO && after != before {
+            // The scroll keeps going without new input.
+            ui.ctx().request_repaint();
+        }
         scroll_area = scroll_area.scroll_offset(after);
     }
     if app.canvas.wheel.is_animating() {
@@ -439,28 +582,23 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
         for (i, pr) in geo.rects.iter().enumerate() {
             let sr = pr.translate(content_origin.to_vec2());
             let Some(page) = layout.pages.get(i) else { continue };
+            let (band_top, band_bot) = geo.bands.get(i).copied().unwrap_or((0.0, sr.height()));
             let scale_px = (geo.scale * ppp).min(max_tex / page.w.max(1.0)).min(max_tex / page.h.clamp(1.0, 1e6)).max(0.05);
             let key = page_key(app, page, scale_px, dim_body);
-            let fresh = app.canvas.textures.get(&i).is_some_and(|(k, _)| *k == key);
-            let current_scale = geo.scale * ppp;
-            let visual_sr = if fresh && (scale_px - current_scale).abs() <= 0.0001_f32.max(current_scale.abs() * 0.0001) {
-                app.canvas.textures.get(&i).map_or(sr, |(_, tex)| texel_aligned_rect(sr, tex.size_vec2(), ppp))
-            } else {
-                sr
-            };
-            rects.push(visual_sr);
-            if !sr.intersects(ui.clip_rect().expand(200.0)) {
-                continue;
-            }
-            // Shadow and paper.
-            painter.rect_filled(visual_sr.translate(vec2(0.0, 2.0)).expand(1.5), 1.0, t.page_shadow);
-            painter.rect_filled(visual_sr, 0.0, if dark_page { Color32::from_gray(dark_paper) } else { Color32::WHITE });
-            if !fresh && (rendered < 2 || !app.canvas.textures.contains_key(&i) && rendered < 4) {
+            let mut fresh = app.canvas.textures.get(&i).is_some_and(|(k, _)| *k == key);
+            // Hide White Space shows only a band of the page; everything below paints into it.
+            let band_of = |r: Rect| Rect::from_min_max(pos2(r.min.x - 4.0, r.min.y + band_top), pos2(r.max.x + 4.0, r.min.y + band_bot));
+            let visible = band_of(sr).intersects(ui.clip_rect().expand(200.0));
+            // Render before placing the page: a page re-rendered in this frame (a zoom step, an
+            // edit) then sits on the pixel grid in this frame too, rather than a frame later.
+            if visible && !fresh && (rendered < 2 || !app.canvas.textures.contains_key(&i) && rendered < 4) {
                 let mut opts = screen_render_options();
                 opts.display.marks = app.session.view.marks;
+                opts.display.always = app.session.prefs.marks;
                 opts.display.placeholders = true;
                 opts.display.markup = app.session.view.show_markup;
-                opts.display.hide_ink = app.session.view.hide_ink;
+                // Ink Replay draws the ink itself, stroke by stroke, over pages without it.
+                opts.display.hide_ink = app.session.view.hide_ink || app.session.view.draw.replay;
                 opts.display.revisions = app.session.prefs.markup.clone();
                 opts.dark = dark_page;
                 opts.dark_paper = dark_paper;
@@ -480,9 +618,29 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
                     }
                 }
                 rendered += 1;
-            } else if !fresh {
+                fresh = true;
+            } else if visible && !fresh {
                 ui.ctx().request_repaint();
             }
+            let current_scale = geo.scale * ppp;
+            let visual_sr = if fresh && (scale_px - current_scale).abs() <= 0.0001_f32.max(current_scale.abs() * 0.0001) {
+                app.canvas.textures.get(&i).map_or(sr, |(_, tex)| texel_aligned_rect(sr, tex.size_vec2(), ppp))
+            } else {
+                sr
+            };
+            rects.push(visual_sr);
+            if !visible {
+                continue;
+            }
+            let band = band_of(visual_sr);
+            let painter = if band_top <= 0.0 && band_bot >= sr.height() {
+                painter.clone()
+            } else {
+                painter.with_clip_rect(painter.clip_rect().intersect(band))
+            };
+            // Shadow and paper.
+            painter.rect_filled(visual_sr.translate(vec2(0.0, 2.0)).expand(1.5), 1.0, t.page_shadow);
+            painter.rect_filled(visual_sr, 0.0, if dark_page { Color32::from_gray(dark_paper) } else { Color32::WHITE });
             if let Some((_, tex)) = app.canvas.textures.get(&i) {
                 painter.image(tex.id(), visual_sr, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), Color32::WHITE);
             }
@@ -532,7 +690,7 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
             // Table Layout › View Gridlines: table cell outlines (on screen only).
             if app.session.view.table_gridlines {
                 for it in &page.items {
-                    if let Placed::Cell { rect, .. } = it {
+                    if let Placed::Cell { rect, covered: false, .. } = it {
                         let r = Rect::from_min_size(
                             pos2(visual_sr.min.x + rect.x * page_scale, visual_sr.min.y + rect.y * page_scale),
                             vec2(rect.w * page_scale, rect.h * page_scale),
@@ -542,6 +700,14 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
                 }
             }
         }
+        // Hide White Space: a thin line where one page ends and the next begins.
+        for (i, pair) in rects.windows(2).enumerate() {
+            let Some(&(_, bot)) = geo.bands.get(i) else { continue };
+            if white_space_hidden(&geo.rects, &geo.bands) {
+                let y = pair[0].min.y + bot;
+                painter.rect_filled(Rect::from_min_max(pos2(pair[0].min.x, y), pos2(pair[0].max.x, y + SEAM)), 0.0, t.border_strong);
+            }
+        }
         if rendered > 0 {
             app.canvas.render_ms = crate::now_ms() - t0;
         }
@@ -586,6 +752,8 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
         } else {
             app.canvas.mini_anchor = None;
         }
+        // Content controls: the frame of the one the caret is in (all of them in Design Mode).
+        crate::content_controls::paint(app, &painter, &t, &layout, &rects, geo.scale);
         // Read Aloud: the sentence being spoken.
         if let Some((a, b)) = crate::read_aloud::highlight(app) {
             for (pi, r) in layout.selection_rects(&app.session.doc, &a, &b, app.session.page_hint) {
@@ -617,8 +785,11 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
                 let y0 = pr.min.y + (base - slot.y - slot.a) * s;
                 let y1 = pr.min.y + (base - slot.y + slot.d) * s;
                 let since = crate::now_ms() - app.canvas.caret_visible_since;
-                if ((since / 530.0) as u64).is_multiple_of(2) && focused {
-                    painter.line_segment([pos2(x, y0), pos2(x, y1)], Stroke::new(1.5, t.caret));
+                // The caret glides and fades like Word's (`caret_glide`).
+                let on = ((since / 530.0) as u64).is_multiple_of(2);
+                let look = crate::caret_glide::look(app, ui, content_origin, &geo, [pos2(x, y0), pos2(x, y1)], focused, since, on);
+                if look.opacity > 0.0 && focused {
+                    painter.line_segment(look.bar, Stroke::new(1.5, t.caret.gamma_multiply(look.opacity)));
                 }
                 if focused {
                     ui.ctx().request_repaint_after(std::time::Duration::from_millis(530 - (since as u64 % 530)));
@@ -644,14 +815,17 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
             let y1 = y0 + c.height * scale;
             let since = crate::now_ms() - app.canvas.caret_visible_since;
             let on = ((since / 530.0) as u64).is_multiple_of(2);
-            if app.session.sel.is_collapsed() && on && focused {
-                let bar = if c.width > 0.0 {
-                    // Turned text (a table cell's text direction): the caret lies across the page.
-                    [pos2(x, y0.round() + 0.5), pos2(x + c.width * scale, y0.round() + 0.5)]
-                } else {
-                    [pos2(x.round() + 0.5, y0), pos2(x.round() + 0.5, y1)]
-                };
-                painter.line_segment(bar, Stroke::new(1.5, caret_color));
+            let bar = if c.width > 0.0 {
+                // Turned text (a table cell's text direction): the caret lies across the page.
+                [pos2(x, y0.round() + 0.5), pos2(x + c.width * scale, y0.round() + 0.5)]
+            } else {
+                [pos2(x.round() + 0.5, y0), pos2(x.round() + 0.5, y1)]
+            };
+            // The caret glides and fades like Word's (`caret_glide`).
+            let shown = app.session.sel.is_collapsed() && focused;
+            let look = crate::caret_glide::look(app, ui, content_origin, &geo, bar, shown, since, on);
+            if shown && look.opacity > 0.0 {
+                painter.line_segment(look.bar, Stroke::new(1.5, caret_color.gamma_multiply(look.opacity)));
             }
             if focused {
                 ui.ctx().request_repaint_after(std::time::Duration::from_millis(530 - (since as u64 % 530)));
@@ -665,6 +839,19 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
                 });
             }
             if !app.canvas.ime_preedit.is_empty() {
+                // The composition is interface text, but it may be in a script the interface fonts lack
+                // (Bangla, Thai ...): borrow the document fonts' fallback faces, or it draws as boxes (#565).
+                let new = crate::theme::faces_for_preedit(
+                    &app.canvas.ime_preedit,
+                    &app.canvas.ime_faces,
+                    |c| (c as u32) < 0x250,
+                    |c| wordcraft_fonts::FontDb::global().fallback_for(c, u32::MAX),
+                );
+                if !new.is_empty() {
+                    app.canvas.ime_faces.extend(new);
+                    crate::theme::install_fonts_extra(ui.ctx(), app.fonts_hans, app.fonts_system_cjk, &app.canvas.ime_faces);
+                    ui.ctx().request_repaint();
+                }
                 let g = painter.text(pos2(x, y1), egui::Align2::LEFT_BOTTOM, &app.canvas.ime_preedit, regular(c.height * scale * 0.8), caret_color);
                 painter.line_segment([pos2(g.min.x, g.max.y), pos2(g.max.x, g.max.y)], Stroke::new(1.0, caret_color));
             }
@@ -672,10 +859,15 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
         crate::objects::paint(app, &painter, &t, &layout, &rects, geo.scale);
         crate::ink::paint(app, &painter, &rects, &layout, geo.scale);
         crate::table_pen::paint(app, &painter, &t, &layout, &rects, geo.scale);
+        crate::table_resize::paint(app, &painter, &t, &layout, &rects, geo.scale);
         (resp, rects)
     });
     app.canvas.scroll_offset = out.state.offset;
+    crate::ink::replay_bar(app, ui, out.inner_rect);
     app.canvas.scroll_max = (out.content_size - out.inner_rect.size()).max(egui::Vec2::ZERO);
+    // The viewport barely moves between frames; the auto-scroll decides this frame's scroll before
+    // the scroll area is built, so it reads last frame's viewport.
+    app.canvas.viewport = Some(out.inner_rect);
     let (resp, rects) = out.inner;
     // A click on the page leaves the selected comment balloon.
     if app.canvas.balloon.is_some() && ui.input(|i| i.pointer.any_pressed()) && resp.contains_pointer() {
@@ -692,10 +884,23 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
         });
     }
     app.canvas.focused = resp.has_focus();
+    // Screen readers: the document under the canvas, with the caret (#488).
+    crate::a11y::expose(app, ui.ctx(), resp.id, &layout, &rects, area);
+    // Double-click the space between two pages (or the line between them) to hide or show it.
+    if resp.double_clicked()
+        && app.session.view.mode == wordcraft_layout::ViewMode::Print
+        && !app.session.view.read_mode
+        && let Some(p) = resp.interact_pointer_pos()
+        && on_page_gap(&rects, &geo.bands, p)
+    {
+        let _ = app.run("view.hideWhiteSpace", json!({"value": !app.session.view.hide_white_space}));
+    } else
     // Draw Table / Eraser own the mouse while on (no caret moves); else the usual editing.
     if !crate::table_pen::pointer(app, ui, &resp, &rects, &layout, geo.scale) {
         mouse(app, ui, &resp, &rects, &layout, geo.scale);
     }
+    // A click on a check box ticks it; on a list's button opens the list.
+    crate::content_controls::clicks(app, &resp);
     // Right-click: move the caret there (unless inside the selection), then the context menu.
     // Right-click in an equation puts the caret there and opens the equation menu.
     if resp.secondary_clicked()
@@ -713,18 +918,23 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
             None => {}
         }
     }
+    // Right-click on a picture, shape or text box selects it (its menu offers Wrap Text).
     if resp.secondary_clicked()
         && app.session.math.is_none()
         && let Some(p) = resp.interact_pointer_pos()
         && let Some((page, x, y)) = page_at(&rects, &layout, geo.scale, p)
-        && let Some(pos) = layout.hit(page, x, y, app.session.sel.focus.story)
     {
-        let (a, b) = app.session.sel.ordered();
-        if !(a <= pos && pos <= b) || app.session.sel.is_collapsed() {
-            app.session.sel = wordcraft_engine::Selection::caret(pos);
+        if crate::objects::select_at(app, &layout, &rects, geo.scale, p) {
+            app.canvas.context_issue = None;
+            app.canvas.context_synonyms = None;
+        } else if let Some(pos) = layout.hit(page, x, y, app.session.sel.focus.story) {
+            let (a, b) = app.session.sel.ordered();
+            if !(a <= pos && pos <= b) || app.session.sel.is_collapsed() {
+                app.session.sel = wordcraft_engine::Selection::caret(pos);
+            }
+            app.canvas.context_issue = app.session.run("review.suggestions", &json!({})).ok().filter(|v| !v.is_null());
+            app.canvas.context_synonyms = app.session.run("review.thesaurus", &json!({})).ok().and_then(|v| v.get("synonyms").cloned());
         }
-        app.canvas.context_issue = app.session.run("review.suggestions", &json!({})).ok().filter(|v| !v.is_null());
-        app.canvas.context_synonyms = app.session.run("review.thesaurus", &json!({})).ok().and_then(|v| v.get("synonyms").cloned());
     }
     resp.context_menu(|ui| context_menu(app, ui));
     // Stand down while the context menu owns the pointer so the two never double up;
@@ -736,6 +946,7 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
         let over_object = ui.input(|i| i.pointer.latest_pos()).and_then(|p| crate::objects::cursor(app, &layout, &rects, geo.scale, p));
         ui.ctx().set_cursor_icon(over_object.unwrap_or(egui::CursorIcon::Text));
     }
+    crate::table_resize::cursor(app, ui, &resp, &layout, &rects, geo.scale);
     crate::table_pen::cursor(app, ui, &resp);
     // While "Save changes?" is up, keys answer it rather than edit the document behind it.
     if app.canvas.focused && !matches!(app.dialog, Some(crate::dialogs::Dialog::SaveChanges { .. })) {
@@ -745,7 +956,9 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
     if let (Some(h), Some(v)) = (hruler, vruler) {
         rulers(app, ui, h, v, &rects, &layout, geo.scale);
     }
-    if let Some(sel) = app.canvas.mini_anchor {
+    if let Some(sel) = app.canvas.mini_anchor
+        && app.ui.mini_toolbar
+    {
         crate::mini_toolbar::show(app, ui.ctx(), sel, area);
     }
 }
@@ -772,8 +985,9 @@ fn balloons(app: &mut WordApp, ui: &mut Ui, painter: &egui::Painter, rects: &[Re
             replies.entry(p).or_default().push(*id);
         }
     }
-    // (page, anchor x, anchor y, item) for each anchored, unresolved-or-not comment, and each
-    // tracked formatting change (Word's default shows those in balloons too).
+    // (page, anchor x, anchor y, item) for each anchored, unresolved-or-not comment, each
+    // tracked formatting change (Word's default shows those in balloons too) and, when revisions
+    // go in balloons, each tracked deletion.
     let mut by_page: HashMap<usize, Vec<(f32, f32, Balloon, Pos)>> = HashMap::new();
     let m = &app.session.prefs.markup;
     let comments = if m.comments { wordcraft_engine::cmd::review::comment_list(&app.session) } else { Vec::new() };
@@ -799,6 +1013,13 @@ fn balloons(app: &mut WordApp, ui: &mut Ui, painter: &egui::Painter, rects: &[Re
         let text = if from { tl!("Moved from") } else { tl!("Moved to") }.to_string();
         by_page.entry(c.page).or_default().push((c.x, c.top + c.height, Balloon::Format(author, text), pos));
     }
+    // Show revisions in balloons: each tracked deletion, taken out of the text, at its place.
+    let deletions = if app.session.revisions_in_balloons() { wordcraft_engine::cmd::review::deletion_balloons(&app.session) } else { Vec::new() };
+    for d in deletions {
+        let Some(c) = layout.caret_on(&d.at, app.session.page_hint) else { continue };
+        let text = format!("{}: {}", tl!("Deleted"), d.text);
+        by_page.entry(c.page).or_default().push((c.x, c.top + c.height, Balloon::Format(d.author, text), d.at));
+    }
     let palette = [t.blue, Color32::from_rgb(0xB0, 0x3A, 0x2E), Color32::from_rgb(0x2E, 0x7D, 0x32), Color32::from_rgb(0x8E, 0x44, 0xAD), t.orange];
     let mut authors: Vec<String> = Vec::new();
     let mut clicked: Option<(u32, Pos)> = None;
@@ -933,7 +1154,8 @@ fn balloons(app: &mut WordApp, ui: &mut Ui, painter: &egui::Painter, rects: &[Re
 /// What a balloon in the markup area shows.
 enum Balloon {
     Comment(u32),
-    /// A tracked formatting change or move: its author and "Formatted: …" / "Moved from".
+    /// A tracked formatting change, move or deletion: its author and "Formatted: …" /
+    /// "Moved from" / "Deleted: …".
     Format(String, String),
 }
 
@@ -1057,7 +1279,8 @@ pub fn nearest_page(rects: &[Rect], p: Pos2) -> Option<usize> {
     let mut best: Option<(usize, f32)> = None;
     for (i, r) in rects.iter().enumerate() {
         let d = if r.contains(p) {
-            0.0
+            // Pages overlap in the margins Hide White Space cuts: the one whose middle is nearer wins.
+            1e-3 * (p.y - r.center().y).abs() / r.height().max(1.0)
         } else {
             let dx = (r.min.x - p.x).max(p.x - r.max.x).max(0.0);
             let dy = (r.min.y - p.y).max(p.y - r.max.y).max(0.0);
@@ -1070,6 +1293,32 @@ pub fn nearest_page(rects: &[Rect], p: Pos2) -> Option<usize> {
     best.map(|(i, _)| i)
 }
 
+/// The drag auto-scroll along one axis for a pointer at `p` inside the viewport band `lo..hi`, in
+/// the wheel's convention (positive = content moves down the screen, toward the document's start):
+/// nothing while the pointer is [`EDGE_MARGIN`] or more inside, then ramping from
+/// [`EDGE_SPEED_MIN`] at the margin to [`EDGE_SPEED_MAX`] at the edge (and capping beyond it),
+/// applied over `dt` seconds. Junk numbers scroll nothing.
+fn edge_scroll(p: f32, lo: f32, hi: f32, dt: f32) -> f32 {
+    if !(p.is_finite() && lo.is_finite() && hi.is_finite() && dt.is_finite()) || hi <= lo {
+        return 0.0;
+    }
+    let dt = dt.clamp(0.0, EDGE_MAX_DT);
+    let speed = |into: f32| egui::emath::lerp(EDGE_SPEED_MIN..=EDGE_SPEED_MAX, (into / EDGE_MARGIN).clamp(0.0, 1.0));
+    if p < lo + EDGE_MARGIN {
+        speed(lo + EDGE_MARGIN - p) * dt
+    } else if p > hi - EDGE_MARGIN {
+        -speed(p - (hi - EDGE_MARGIN)) * dt
+    } else {
+        0.0
+    }
+}
+
+/// The scroll offset after `delta` (the wheel's convention) reaches `before`: clamped to the
+/// scrollable range, so a document shorter than the viewport never moves.
+fn clamped_scroll(before: egui::Vec2, delta: egui::Vec2, max: egui::Vec2) -> egui::Vec2 {
+    (before - delta).clamp(egui::Vec2::ZERO, max)
+}
+
 fn mouse(app: &mut WordApp, ui: &Ui, resp: &egui::Response, rects: &[Rect], layout: &DocLayout, scale: f32) {
     // A pen or the eraser (Draw tab) owns the pointer.
     if crate::ink::pointer(app, ui, resp, rects, layout, scale) {
@@ -1083,7 +1332,22 @@ fn mouse(app: &mut WordApp, ui: &Ui, resp: &egui::Response, rects: &[Rect], layo
     {
         return;
     }
+    // A press on a table border (or the table's resize handle) drags it instead of the caret.
+    if crate::table_resize::pointer(app, ui, resp, rects, layout, scale) {
+        return;
+    }
     let Some(p) = pointer else { return };
+    // While drag-selecting, the pointer may sit past the viewport's edge (or the window's):
+    // hit-test where it would be inside the view, so as the edge auto-scroll moves the content the
+    // selection keeps growing under a stationary pointer (#688).
+    let p = if app.canvas.dragging
+        && ui.input(|i| i.pointer.primary_down())
+        && let Some(vp) = app.canvas.viewport
+    {
+        vp.clamp(p)
+    } else {
+        p
+    };
     let Some((page, x, y)) = page_at(rects, layout, scale, p) else { return };
     let mods = ui.input(|i| i.modifiers);
     let story = app.session.sel.focus.story;
@@ -1091,6 +1355,32 @@ fn mouse(app: &mut WordApp, ui: &Ui, resp: &egui::Response, rects: &[Rect], layo
     if (resp.double_clicked() || resp.triple_clicked()) && layout.equation_hit(page, x, y, story).is_some() {
         return;
     }
+    // Outline view: a paragraph's symbol selects it with what is under it; a double-click
+    // expands or collapses the heading.
+    if app.session.view.mode == wordcraft_layout::ViewMode::Outline
+        && let Some(block) = layout.outline_symbol_at(page, x, y)
+    {
+        if resp.double_clicked() {
+            let _ = app.run("outline.toggle", json!({ "block": block }));
+        } else if ui.input(|i| i.pointer.primary_pressed()) && resp.contains_pointer() {
+            let _ = app.run("outline.selectSubtree", json!({ "block": block }));
+            app.session.page_hint = page;
+        }
+        return;
+    }
+    // The press already selected the word or paragraph (and a drag may have grown it).
+    let released_clicks = if resp.triple_clicked() {
+        3
+    } else if resp.double_clicked() {
+        2
+    } else {
+        0
+    };
+    if released_clicks > 0 && app.canvas.unit_drag.as_ref().is_some_and(|d| d.clicks == released_clicks) {
+        app.canvas.unit_drag = None;
+        app.canvas.dragging = false;
+        return;
+    }
     // Double-click in the header/footer area edits it; double-click in the body leaves it.
     if resp.double_clicked() {
         if let Some((s, header)) = layout.header_footer_at(page, y)
@@ -1128,6 +1418,14 @@ fn mouse(app: &mut WordApp, ui: &Ui, resp: &egui::Response, rects: &[Rect], layo
     }
     let pressed = ui.input(|i| i.pointer.primary_pressed()) && resp.contains_pointer();
     if pressed {
+        let now = ui.input(|i| i.time);
+        let (delay, dist) = ui.ctx().options(|o| (o.input_options.max_double_click_delay, o.input_options.max_click_dist));
+        let clicks = press_count(app.canvas.last_press, now, p, delay, dist);
+        app.canvas.last_press = Some((now, p, clicks));
+        app.canvas.unit_drag = None;
+        // A double-click that enters or leaves a header/footer is handled on release.
+        let hf_switch = (layout.header_footer_at(page, y).is_some() && story == StoryRef::Body)
+            || (matches!(story, StoryRef::Part(_)) && !in_text_box(app) && layout.header_footer_at(page, y).is_none());
         // Clicking into a footnote/endnote or a text box edits it; clicking outside a text box goes
         // back to where it is. While editing a header/footer, only its own text boxes are in reach.
         let story = {
@@ -1181,8 +1479,19 @@ fn mouse(app: &mut WordApp, ui: &Ui, resp: &egui::Response, rects: &[Rect], layo
         }
         app.canvas.column_drag = None;
         let _ = app.run("caret.set", json!({"pos": pj, "extend": mods.shift}));
-        if mods.command && !mods.shift {
-            let _ = app.run("select.sentence", json!({}));
+        // Double-click selects a word, triple-click a paragraph, Ctrl/⌘+click a sentence; holding
+        // the button and dragging then extends by whole units (Word, #549).
+        let unit = match clicks {
+            _ if mods.shift => None,
+            3 if !hf_switch => Some("paragraph"),
+            2 if !hf_switch => Some("word"),
+            1 if mods.command => Some("sentence"),
+            _ => None,
+        };
+        if let Some(unit) = unit {
+            let _ = app.run(&format!("select.{unit}"), json!({}));
+            let (start, end) = app.session.sel.ordered();
+            app.canvas.unit_drag = Some(UnitDrag { unit, clicks, start, end, last: pos });
         }
         app.session.page_hint = page;
         app.canvas.dragging = true;
@@ -1199,6 +1508,19 @@ fn mouse(app: &mut WordApp, ui: &Ui, resp: &egui::Response, rects: &[Rect], layo
                 json!({"from": {"page": from.0, "x": from.1, "y": from.2}, "to": {"page": page, "x": x, "y": y}, "story": story}),
             );
         }
+    } else if app.canvas.dragging
+        && ui.input(|i| i.pointer.primary_down())
+        && let Some(d) = app.canvas.unit_drag.as_mut()
+    {
+        if let Some(pos) = layout.hit(page, x, y, story)
+            && pos != d.last
+        {
+            d.last = pos.clone();
+            let params = json!({"unit": d.unit, "start": d.start, "end": d.end, "pos": pos});
+            let _ = app.run("select.dragUnit", params);
+            app.session.page_hint = page;
+            app.canvas.caret_visible_since = crate::now_ms();
+        }
     } else if app.canvas.dragging && ui.input(|i| i.pointer.primary_down()) {
         if let Some(pos) = layout.hit(page, x, y, story)
             && pos != app.session.sel.focus
@@ -1207,10 +1529,12 @@ fn mouse(app: &mut WordApp, ui: &Ui, resp: &egui::Response, rects: &[Rect], layo
             app.session.page_hint = page;
             app.canvas.caret_visible_since = crate::now_ms();
         }
-        // Auto-scroll near the edges is handled by egui's scroll area drag.
+        // The pointer was clamped into the viewport above, so when the edge auto-scroll moves the
+        // content under it, this hit-test keeps the selection growing (#688).
     } else if app.canvas.dragging && ui.input(|i| i.pointer.primary_released()) {
         app.canvas.dragging = false;
         app.canvas.column_drag = None;
+        app.canvas.unit_drag = None;
         if app.session.painter.is_some() && !app.session.sel.is_collapsed() {
             let _ = app.run("edit.pasteFormat", json!({}));
         }
@@ -1247,40 +1571,26 @@ fn rulers(app: &mut WordApp, ui: &mut Ui, h: Rect, v: Rect, rects: &[Rect], layo
     hp.rect_filled(bar, 0.0, t.ruler_margin);
     let text = Rect::from_min_max(pos2(x0 + page.body.x * scale, bar.min.y), pos2(x0 + page.body.right() * scale, bar.max.y));
     hp.rect_filled(text, 0.0, t.ruler);
-    let unit = 72.0;
-    let origin = page.body.x;
-    let mut k = -((origin / unit).ceil() as i32) * 8;
-    loop {
-        let xpt = origin + k as f32 * unit / 8.0;
-        if xpt > page.w {
-            break;
-        }
-        if xpt >= 0.0 {
-            let sx = x0 + xpt * scale;
-            let (len, label) = if k % 8 == 0 {
-                (0.0, Some(k / 8))
-            } else if k % 4 == 0 {
-                (5.0, None)
-            } else if k % 2 == 0 {
-                (3.0, None)
-            } else {
-                (1.5, None)
-            };
-            match label {
-                Some(n) if n != 0 => {
-                    hp.text(pos2(sx, bar.center().y), egui::Align2::CENTER_CENTER, n.abs().to_string(), regular(9.5), t.ruler_tick);
-                }
-                Some(_) => {}
-                None => {
-                    if scale * unit / 8.0 > 4.0 || k % 2 == 0 {
-                        hp.line_segment([pos2(sx, bar.center().y - len / 2.0), pos2(sx, bar.center().y + len / 2.0)], Stroke::new(1.0, t.ruler_tick));
-                    }
-                }
+    let rp = app.session.doc.para_at(&app.session.sel.focus).map(|para| app.session.doc.styles.resolve_para(&para.props));
+    // Graduations in the File › Options unit.
+    let (unit, div, step) = ruler_scale(app.session.prefs.units);
+    // The caret paragraph's reading direction anchors the whole scale (#692): for a right-to-left
+    // paragraph it runs from the page's right edge and the numbers increase right-to-left, so the
+    // ruler matches the indent and tab markers, which sit at the paragraph's start edge.
+    let rtl = rp.as_ref().is_some_and(|rp| rp.bidi);
+    let origin = if rtl { page.w - page.body.right() } else { page.body.x };
+    // A distance along the reading direction (points from the page's start edge) and back.
+    let sx = |d: f32| ruler_x(d, x0, scale, page.w, rtl);
+    let s_at = |x: f32| ruler_d(x, x0, scale, page.w, rtl);
+    for (d, mark) in ruler_marks(origin, page.w, (unit, div, step), scale) {
+        let x = sx(d);
+        match mark {
+            RulerMark::Label(n) => {
+                hp.text(pos2(x, bar.center().y), egui::Align2::CENTER_CENTER, n.abs().to_string(), regular(9.5), t.ruler_tick);
+            }
+            RulerMark::Tick(len) => {
+                hp.line_segment([pos2(x, bar.center().y - len / 2.0), pos2(x, bar.center().y + len / 2.0)], Stroke::new(1.0, t.ruler_tick));
             }
-        }
-        k += 1;
-        if k > 400 {
-            break;
         }
     }
     // Margins: the edges of the white text area drag the section's margins. Registered before
@@ -1294,17 +1604,15 @@ fn rulers(app: &mut WordApp, ui: &mut Ui, h: Rect, v: Rect, rects: &[Rect], layo
     }
     // Indent markers for the caret's paragraph (relative to its column).
     let col_x = page.body.x;
-    if let Some(para) = app.session.doc.para_at(&app.session.sel.focus) {
-        let rp = app.session.doc.styles.resolve_para(&para.props);
+    if let Some(rp) = rp {
         // Indents and tabs are measured from the paragraph's start edge: the right margin of a
         // right-to-left paragraph, where the start-indent markers sit.
-        let rtl = rp.bidi;
         let w = page.body.w;
-        let sx = |s: f32| if rtl { x0 + (col_x + w - s) * scale } else { x0 + (col_x + s) * scale };
-        let s_at = |x: f32| if rtl { col_x + w - (x - x0) / scale } else { (x - x0) / scale - col_x };
-        let first = sx(rp.indent_left + rp.indent_first);
-        let left = sx(rp.indent_left);
-        let right = sx(w - rp.indent_right);
+        let px = |s: f32| sx(origin + s);
+        let dist_at = |x: f32| s_at(x) - origin;
+        let first = px(rp.indent_left + rp.indent_first);
+        let left = px(rp.indent_left);
+        let right = px(w - rp.indent_right);
         let c = t.text_dim;
         hp.add(egui::Shape::convex_polygon(
             vec![pos2(first - 4.5, bar.min.y), pos2(first + 4.5, bar.min.y), pos2(first, bar.min.y + 5.0)],
@@ -1330,7 +1638,7 @@ fn rulers(app: &mut WordApp, ui: &mut Ui, h: Rect, v: Rect, rects: &[Rect], layo
         ));
         let mut open_tabs = false;
         for (i, tab) in rp.tabs.iter().enumerate() {
-            let tx = sx(tab.pos);
+            let tx = px(tab.pos);
             let foot = if rtl { -4.0 } else { 4.0 };
             hp.line_segment([pos2(tx, bar.max.y - 6.0), pos2(tx, bar.max.y - 1.0)], Stroke::new(1.5, t.text));
             hp.line_segment([pos2(tx, bar.max.y - 1.0), pos2(tx + foot, bar.max.y - 1.0)], Stroke::new(1.5, t.text));
@@ -1348,7 +1656,7 @@ fn rulers(app: &mut WordApp, ui: &mut Ui, h: Rect, v: Rect, rects: &[Rect], layo
         if r.dragged()
             && let Some(pp) = r.interact_pointer_pos()
         {
-            let pt = s_at(pp.x).clamp(-col_x, page.body.w - 18.0);
+            let pt = dist_at(pp.x).clamp(-col_x, page.body.w - 18.0);
             let snapped = (pt / 4.5).round() * 4.5;
             if !r.drag_started() {
                 app.session.join_next_undo();
@@ -1360,7 +1668,7 @@ fn rulers(app: &mut WordApp, ui: &mut Ui, h: Rect, v: Rect, rects: &[Rect], layo
         if r.dragged()
             && let Some(pp) = r.interact_pointer_pos()
         {
-            let pt = s_at(pp.x) - rp.indent_left;
+            let pt = dist_at(pp.x) - rp.indent_left;
             if !r.drag_started() {
                 app.session.join_next_undo();
             }
@@ -1371,7 +1679,7 @@ fn rulers(app: &mut WordApp, ui: &mut Ui, h: Rect, v: Rect, rects: &[Rect], layo
         if r.dragged()
             && let Some(pp) = r.interact_pointer_pos()
         {
-            let pt = page.body.w - s_at(pp.x);
+            let pt = page.body.w - dist_at(pp.x);
             if !r.drag_started() {
                 app.session.join_next_undo();
             }
@@ -1390,15 +1698,21 @@ fn rulers(app: &mut WordApp, ui: &mut Ui, h: Rect, v: Rect, rects: &[Rect], layo
         margin_handle(app, ui, edge, zone, |p| (p.y - y0) / scale, &sect);
     }
     let origin = page.body.y;
-    let mut k = -((origin / unit).ceil() as i32) * 8;
+    let mut k = -((origin / unit).ceil() as i32) * div;
     loop {
-        let ypt = origin + k as f32 * unit / 8.0;
+        let ypt = origin + k as f32 * unit / div as f32;
         if ypt > page.h.min(20_000.0) {
             break;
         }
-        if ypt >= 0.0 && k % 8 == 0 && k != 0 {
-            vp.text(pos2(vbar.center().x, y0 + ypt * scale), egui::Align2::CENTER_CENTER, (k / 8).abs().to_string(), regular(9.5), t.ruler_tick);
-        } else if ypt >= 0.0 && k % 4 == 0 {
+        if ypt >= 0.0 && k % div == 0 && k != 0 {
+            vp.text(
+                pos2(vbar.center().x, y0 + ypt * scale),
+                egui::Align2::CENTER_CENTER,
+                (k / div * step).abs().to_string(),
+                regular(9.5),
+                t.ruler_tick,
+            );
+        } else if ypt >= 0.0 && k % (div / 2) == 0 {
             let sy = y0 + ypt * scale;
             vp.line_segment([pos2(vbar.center().x - 2.5, sy), pos2(vbar.center().x + 2.5, sy)], Stroke::new(1.0, t.ruler_tick));
         }
@@ -1409,6 +1723,78 @@ fn rulers(app: &mut WordApp, ui: &mut Ui, h: Rect, v: Rect, rects: &[Rect], layo
     }
 }
 
+/// One mark drawn along a horizontal ruler.
+#[derive(Clone, Copy, Debug, PartialEq)]
+enum RulerMark {
+    /// A whole-inch number, `n` inches from the start margin.
+    Label(i32),
+    /// A tick line, `len` screen points long.
+    Tick(f32),
+}
+
+/// The marks of a horizontal ruler with their distance from the page's start edge (points along
+/// the reading direction): ticks every 1/8 inch past `origin` (the start margin, so the margin is
+/// numbered backwards to the page edge) out to `width`, their labels counting whole inches from
+/// the start margin. Sub-half-inch ticks drop out when they'd sit closer than ~4 screen points.
+fn ruler_marks(origin: f32, width: f32, (unit, div, step): (f32, i32, i32), scale: f32) -> Vec<(f32, RulerMark)> {
+    let div = div.max(2);
+    let mut marks = Vec::new();
+    let mut k = -((origin / unit).ceil() as i32) * div;
+    loop {
+        let d = origin + k as f32 * unit / div as f32;
+        if d > width {
+            break;
+        }
+        if d >= 0.0 {
+            let mark = if k % div == 0 {
+                (k != 0).then_some(RulerMark::Label(k / div * step))
+            } else if scale * unit / div as f32 > 4.0 || k % 2 == 0 {
+                Some(RulerMark::Tick(if k % (div / 2) == 0 {
+                    5.0
+                } else if div >= 8 && k % (div / 4) == 0 {
+                    3.0
+                } else {
+                    1.5
+                }))
+            } else {
+                None
+            };
+            if let Some(mark) = mark {
+                marks.push((d, mark));
+            }
+        }
+        k += 1;
+        if k > 400 {
+            break;
+        }
+    }
+    marks
+}
+
+/// Screen x of a point `d` points from the page's start edge, on a page whose left edge sits at
+/// `x0` drawn at `scale`. A right-to-left paragraph reads from the right, so its scale mirrors.
+fn ruler_x(d: f32, x0: f32, scale: f32, page_w: f32, rtl: bool) -> f32 {
+    if rtl { x0 + (page_w - d) * scale } else { x0 + d * scale }
+}
+
+/// The inverse of [`ruler_x`]: the distance from the page's start edge under screen `x`.
+fn ruler_d(x: f32, x0: f32, scale: f32, page_w: f32, rtl: bool) -> f32 {
+    if rtl { page_w - (x - x0) / scale } else { (x - x0) / scale }
+}
+
+/// A ruler's graduation for a unit: points per numbered step, divisions per step, and how much
+/// each step counts (millimetre rulers number every centimetre as 10, 20…).
+fn ruler_scale(u: wordcraft_geom::Unit) -> (f32, i32, i32) {
+    use wordcraft_geom::Unit;
+    match u {
+        Unit::Centimeters => (wordcraft_geom::PT_PER_CM, 4, 1),
+        Unit::Millimeters => (wordcraft_geom::PT_PER_CM, 4, 10),
+        Unit::Points => (72.0, 8, 72),
+        Unit::Picas => (72.0, 8, 6),
+        Unit::Inches => (72.0, 8, 1),
+    }
+}
+
 /// One edge of a page's text area on a ruler.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
 pub(crate) enum MarginEdge {
@@ -1495,7 +1881,7 @@ fn part_kind(app: &WordApp, s: StoryRef) -> Option<PartKind> {
 }
 
 /// The story a text box's story sits in (where the box is), when the caret is in a text box.
-fn text_box_host(app: &WordApp, layout: &DocLayout) -> Option<StoryRef> {
+pub(crate) fn text_box_host(app: &WordApp, layout: &DocLayout) -> Option<StoryRef> {
     match app.session.sel.focus.story {
         StoryRef::Part(id) if in_text_box(app) => layout.text_box(id, app.session.page_hint).map(|o| o.story),
         _ => None,
@@ -1651,12 +2037,24 @@ fn context_menu(app: &mut WordApp, ui: &mut Ui) {
         item(ui, app, tl!("Edit Field…"), "fields.setCode", json!({}));
         item(ui, app, tl!("Toggle Field Codes"), "fields.toggleCode", json!({}));
     }
-    if crate::ribbon::has_picture_selected(&app.session) {
+    let selected_object = wordcraft_engine::cmd::objects::selected(&app.session).is_some();
+    if selected_object || app.session.sel.focus.path.cell().is_some() {
+        item(ui, app, "View Alt Text…", "view.altTextPane", json!({"value": true}));
+    }
+    // A selected picture, shape, text box or chart: its own items, then Wrap Text (#513).
+    let picture = crate::ribbon::has_picture_selected(&app.session);
+    let object = wordcraft_engine::cmd::objects::object_selection(&app.session).is_some();
+    if picture || object {
         ui.separator();
+    }
+    if picture {
         item(ui, app, "Change Picture…", "ui.changePicture", json!({}));
         item(ui, app, "Reset Picture", "picture.reset", json!({}));
         item(ui, app, "Size and Crop…", "ui.tab", json!({"tab": "Picture Format"}));
     }
+    if object {
+        ui.menu_button(tl!("Wrap Text"), |ui| crate::ribbon::wrap_text_items(ui, app));
+    }
     if app.session.sel.focus.path.cell().is_some() {
         ui.separator();
         ui.menu_button(tl!("Insert"), |ui| {
@@ -1711,8 +2109,7 @@ fn link_under(app: &WordApp, layout: &DocLayout, page: usize, x: f32, y: f32, po
 /// Whether Ctrl/⌘+click may hand a document's hyperlink to the system: web and email links only,
 /// so a document can't launch `file:` paths, programs or custom-scheme handlers.
 fn is_followable_link(url: &str) -> bool {
-    let Some((scheme, _)) = url.split_once(':') else { return false };
-    ["http", "https", "mailto"].iter().any(|s| scheme.eq_ignore_ascii_case(s))
+    wordcraft_doc::link::is_web_or_mail_link(url)
 }
 
 #[cfg(test)]
@@ -1755,6 +2152,107 @@ mod tests {
         assert_eq!(wordcraft_engine::cmd::page::sect(&app.session).margin_left, sect.margin_left);
     }
 
+    /// Show revisions in balloons: a document whose only revision is a deletion gets the markup
+    /// area for its balloon; the other modes have nothing to show there, and neither does the view
+    /// while the Comments pane is open.
+    #[test]
+    fn a_deletion_alone_opens_the_markup_area_when_revisions_go_in_balloons() {
+        let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
+        a.run("document.setText", json!({"text": "keep gone"})).unwrap();
+        a.run("review.trackChanges", json!({"value": true})).unwrap();
+        a.run("select.range", json!({"anchor": {"block": 0, "off": 5}, "focus": {"block": 0, "off": 9}})).unwrap();
+        a.run("text.delete", json!({})).unwrap();
+        assert_eq!(markup_width(&a), 0.0, "comments and formatting only: nothing to show");
+        a.run("review.trackingOptions", json!({"balloons": "revisions"})).unwrap();
+        assert!(markup_width(&a) > 0.0, "the deletion's balloon needs the markup area");
+        a.run("view.commentsPane", json!({"value": true})).unwrap();
+        assert_eq!(markup_width(&a), 0.0);
+        a.run("view.commentsPane", json!({"value": false})).unwrap();
+        a.run("review.trackingOptions", json!({"insertionsDeletions": false})).unwrap();
+        assert_eq!(markup_width(&a), 0.0, "deletions not shown at all");
+    }
+
+    /// #549: presses count as double/triple as they go down; slow or far presses start again.
+    #[test]
+    fn presses_count_up_to_three() {
+        let at = pos2(100.0, 100.0);
+        assert_eq!(press_count(None, 5.0, at, 0.3, 6.0), 1);
+        assert_eq!(press_count(Some((5.0, at, 1)), 5.1, at, 0.3, 6.0), 2);
+        assert_eq!(press_count(Some((5.1, at, 2)), 5.2, at + vec2(3.0, 0.0), 0.3, 6.0), 3);
+        assert_eq!(press_count(Some((5.2, at, 3)), 5.3, at, 0.3, 6.0), 3, "stays a triple");
+        assert_eq!(press_count(Some((5.0, at, 1)), 5.5, at, 0.3, 6.0), 1, "too slow");
+        assert_eq!(press_count(Some((5.0, at, 1)), 5.1, at + vec2(20.0, 0.0), 0.3, 6.0), 1, "too far");
+        assert_eq!(press_count(Some((5.0, at, 1)), 4.0, at, 0.3, 6.0), 1, "the clock went back");
+    }
+
+    /// #549: double-click a word and drag: the selection grows by whole words; triple-click and
+    /// drag: by whole paragraphs (Word's behaviour).
+    #[test]
+    fn multi_click_drag_extends_by_units() {
+        use egui::{Event, PointerButton};
+        let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
+        a.run("text.insert", json!({"text": "Alpha beta gamma delta\rSecond para\rThird para"})).unwrap();
+        a.run("view.commentsPane", json!({"value": false})).unwrap();
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).with_step_dt(1.0 / 60.0).build_ui_state(
+            |ui, app: &mut WordApp| {
+                let ctx = ui.ctx().clone();
+                app.logic(&ctx);
+                app.ui(ui);
+            },
+            a,
+        );
+        for _ in 0..6 {
+            h.step();
+        }
+        let screen = |h: &mut egui_kittest::Harness<'_, WordApp>, pos: Pos| {
+            let c = h.state_mut().session.layout().caret(&pos).expect("caret");
+            page_to_screen(h.state_mut(), c.page, c.x + 1.0, c.top + c.height / 2.0).expect("on screen")
+        };
+        let button =
+            |at: Pos2, pressed: bool| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
+        let multi_drag = |h: &mut egui_kittest::Harness<'_, WordApp>, from: Pos2, to: Pos2, clicks: usize| {
+            h.event(Event::PointerMoved(from));
+            for i in 0..clicks {
+                h.event(button(from, true));
+                h.step();
+                if i + 1 < clicks {
+                    h.event(button(from, false));
+                    h.step();
+                }
+            }
+            for k in 1..=4 {
+                h.event(Event::PointerMoved(from + (to - from) * (k as f32 / 4.0)));
+                h.step();
+            }
+            h.event(button(to, false));
+            for _ in 0..3 {
+                h.step();
+            }
+        };
+        // Double-click inside "beta", drag into "gamma": "beta gamma " is selected.
+        let (from, to) = (screen(&mut h, Pos::body(0, 8)), screen(&mut h, Pos::body(0, 13)));
+        multi_drag(&mut h, from, to, 2);
+        let (s, e) = h.state().session.sel.ordered();
+        assert_eq!((s, e), (Pos::body(0, 6), Pos::body(0, 17)), "whole words");
+        // Let the double-click time pass, then triple-click the second paragraph and drag into the third.
+        for _ in 0..40 {
+            h.step();
+        }
+        let (from, to) = (screen(&mut h, Pos::body(1, 3)), screen(&mut h, Pos::body(2, 2)));
+        multi_drag(&mut h, from, to, 3);
+        let sel = h.state().session.sel.clone();
+        assert_eq!((sel.anchor, sel.focus), (Pos::body(1, 0), Pos::body(2, 10)), "whole paragraphs");
+        // A plain double-click (no drag) still selects just the word.
+        h.state_mut().run("select.collapse", json!({})).unwrap();
+        for _ in 0..40 {
+            h.step();
+        }
+        let at = screen(&mut h, Pos::body(0, 1));
+        multi_drag(&mut h, at, at, 2);
+        let (s, e) = h.state().session.sel.ordered();
+        assert_eq!((s, e), (Pos::body(0, 0), Pos::body(0, 6)));
+    }
+
     /// #167: a comment balloon edits in place like Word's: click it, type, leave it, and the
     /// comment has the new text as one undo step.
     #[test]
@@ -1803,6 +2301,53 @@ mod tests {
         assert_eq!(h.state().session.doc.plain_text(StoryRef::Part(part)), "Original");
     }
 
+    /// #513: right-clicking a picture selects it and offers Wrap Text, as in Word; choosing
+    /// Square there wraps text around it.
+    #[test]
+    fn right_click_on_a_picture_offers_wrap_text() {
+        use egui_kittest::kittest::Queryable;
+        let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
+        a.run("text.insert", json!({"text": "Text before the picture "})).unwrap();
+        let mut png = Vec::new();
+        let img = image::RgbaImage::from_pixel(40, 20, image::Rgba([200, 30, 30, 255]));
+        image::DynamicImage::ImageRgba8(img).write_to(&mut std::io::Cursor::new(&mut png), image::ImageFormat::Png).unwrap();
+        a.run("insert.picture", json!({"data": wordcraft_engine::cmd::insert::base64_encode(&png), "width": 160})).unwrap();
+        let pos = wordcraft_engine::cmd::objects::selected(&a.session).unwrap().0;
+        a.session.sel = wordcraft_engine::Selection::caret(Pos::body(0, 0));
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
+            |ui, app: &mut WordApp| {
+                let ctx = ui.ctx().clone();
+                app.logic(&ctx);
+                app.ui(ui);
+            },
+            a,
+        );
+        for _ in 0..6 {
+            h.step();
+        }
+        let rect = h.state_mut().session.layout().object(&pos, 0).expect("the picture is laid out").rect;
+        let at = crate::frame::to_screen(h.state().canvas.page_rects[0], h.state().canvas.scale, rect).center();
+        h.event(egui::Event::PointerMoved(at));
+        for pressed in [true, false] {
+            h.event(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Secondary, pressed, modifiers: Default::default() });
+            h.step();
+        }
+        h.step();
+        let picked = wordcraft_engine::cmd::objects::object_selection(&h.state().session).map(|(p, _)| p);
+        assert_eq!(picked, Some(pos.clone()), "the right-click selected the picture");
+        h.get_by_label_contains("Wrap Text").hover();
+        for _ in 0..3 {
+            h.step();
+        }
+        assert!(h.query_by_label_contains("Fix Position on Page").is_some(), "the anchoring choices are offered");
+        h.get_by_label_contains("Square").click();
+        for _ in 0..3 {
+            h.step();
+        }
+        let o = wordcraft_engine::cmd::objects::selected(&h.state().session).unwrap().1;
+        assert_eq!(o.frame().unwrap().2.wrap, wordcraft_doc::para::Wrap::Square);
+    }
+
     #[test]
     fn only_web_and_email_links_are_followed() {
         for ok in ["https://example.com/a?b#c", "http://example.com", "HTTPS://EXAMPLE.COM", "mailto:someone@example.com"] {
@@ -1826,6 +2371,48 @@ mod tests {
         }
     }
 
+    /// #688: the drag auto-scroll waits in the middle, ramps in from both edges and never leaves
+    /// the scrollable range.
+    #[test]
+    fn edge_auto_scroll_ramps_from_the_margins_and_clamps() {
+        let dt = 1.0 / 60.0;
+        let (lo, hi) = (100.0, 500.0);
+        // Nothing while the pointer is inside, including just within the margin.
+        for y in [(lo + hi) / 2.0, lo + EDGE_MARGIN, hi - EDGE_MARGIN] {
+            assert_eq!(edge_scroll(y, lo, hi, dt), 0.0, "y = {y}");
+        }
+        // Direction: above the top edge scrolls back (positive), below the bottom scrolls on
+        // (negative), in the wheel's convention.
+        assert!(edge_scroll(lo + 1.0, lo, hi, dt) > 0.0);
+        assert!(edge_scroll(hi - 1.0, lo, hi, dt) < 0.0);
+        // The ramp grows monotonically from the margin to the edge and caps past it.
+        let above: Vec<f32> = (0..=8).map(|k| edge_scroll(lo + EDGE_MARGIN - k as f32 * EDGE_MARGIN / 8.0, lo, hi, dt)).collect();
+        assert_eq!(above[0], 0.0);
+        assert!(above.windows(2).all(|w| w[0] < w[1] && w[1] > 0.0), "{above:?}");
+        assert_eq!(above[8], EDGE_SPEED_MAX * dt, "the hard edge scrolls at full speed");
+        assert_eq!(edge_scroll(lo - 3.0 * EDGE_MARGIN, lo, hi, dt), above[8], "past the edge the speed caps");
+        let below: Vec<f32> = (0..=4).map(|k| edge_scroll(hi - EDGE_MARGIN + k as f32 * EDGE_MARGIN / 4.0, lo, hi, dt)).collect();
+        assert_eq!(below[0], 0.0);
+        assert!(below.windows(2).all(|w| w[0] > w[1] && w[1] < 0.0), "{below:?}");
+        assert_eq!(below[4], -EDGE_SPEED_MAX * dt);
+        assert_eq!(edge_scroll(hi + 3.0 * EDGE_MARGIN, lo, hi, dt), below[4], "past the edge the speed caps");
+        // A stalled frame doesn't jump the page.
+        assert!(edge_scroll(hi - 1.0, lo, hi, 100.0) <= EDGE_SPEED_MAX * EDGE_MAX_DT + 1e-3);
+        // Junk in, nothing out; neither an empty (or inverted) band.
+        for (p, lo, hi, dt) in
+            [(f32::NAN, lo, hi, dt), (200.0, f32::NAN, hi, dt), (200.0, lo, f32::INFINITY, dt), (200.0, lo, hi, f32::NAN), (200.0, 500.0, 100.0, dt)]
+        {
+            assert_eq!(edge_scroll(p, lo, hi, dt), 0.0);
+        }
+
+        // Applying it clamps to the scrollable range; a document that fits never scrolls.
+        let max = vec2(0.0, 400.0);
+        assert_eq!(clamped_scroll(egui::Vec2::ZERO, vec2(0.0, 50.0), max).y, 0.0, "never past the top");
+        assert_eq!(clamped_scroll(vec2(0.0, 400.0), vec2(0.0, -50.0), max).y, 400.0, "never past the bottom");
+        assert_eq!(clamped_scroll(vec2(0.0, 300.0), vec2(0.0, 50.0), max).y, 250.0);
+        assert_eq!(clamped_scroll(egui::Vec2::ZERO, vec2(0.0, 50.0), egui::Vec2::ZERO).y, 0.0, "nothing to scroll");
+    }
+
     /// Issue #123: zoomed out, pages sit side by side in rows when the width allows; at 100% a
     /// letter page in an ordinary window stays one per row.
     #[test]
@@ -1940,4 +2527,133 @@ mod tests {
 
         assert_eq!(visual, layout);
     }
+
+    /// #692: a right-to-left paragraph mirrors the horizontal ruler's scale: the inch numbers
+    /// count from the right margin, and reading a pointer position back inverts the mapping
+    /// exactly, so the indent drags keep editing the same indents.
+    #[test]
+    fn the_ruler_scale_mirrors_for_right_to_left() {
+        let (x0, scale, page_w, unit) = (100.0, 1.25, 612.0, 72.0);
+        // 0 sits on the page's right edge and the inches rise leftward.
+        assert_eq!(ruler_x(0.0, x0, scale, page_w, true), x0 + page_w * scale);
+        assert_eq!(ruler_x(page_w, x0, scale, page_w, true), x0);
+        // The inches count from the start margin, which is the right one: on an asymmetric page
+        // (body from 72 to 468) 1 sits an inch left of the right body edge, mirroring left-to-right.
+        let (body_x, body_right) = (72.0, 468.0);
+        assert_eq!(ruler_x(body_x + unit, x0, scale, page_w, false), x0 + (body_x + unit) * scale);
+        assert_eq!(ruler_x(page_w - body_right + unit, x0, scale, page_w, true), x0 + (body_right - unit) * scale);
+        // Reading the pointer back inverts placing exactly, both ways: drags see the same indents.
+        for rtl in [false, true] {
+            for d in [0.0, 9.0, 72.0, 306.0, 612.0] {
+                let x = ruler_x(d, x0, scale, page_w, rtl);
+                assert!((ruler_d(x, x0, scale, page_w, rtl) - d).abs() < 1e-3, "rtl={rtl}: {x} reads back near {d}");
+            }
+        }
+
+        // The marks: inches labelled from the start margin (the page edge counts backwards into
+        // the margin, the margin itself has no mark), half inches the long ticks, ending on the
+        // far page edge.
+        let marks = ruler_marks(72.0, page_w, (unit, 8, 1), scale);
+        let at = |d: f32| marks.iter().find(|(td, _)| (*td - d).abs() < 1e-4).map(|(_, m)| *m);
+        assert_eq!(marks.first().map(|(d, _)| *d), Some(0.0));
+        assert_eq!(marks.last().map(|(d, _)| *d), Some(page_w));
+        assert_eq!(at(0.0), Some(RulerMark::Label(-1)));
+        assert_eq!(at(72.0), None);
+        assert_eq!(at(72.0 + unit), Some(RulerMark::Label(1)));
+        assert_eq!(at(72.0 + 2.0 * unit), Some(RulerMark::Label(2)));
+        assert_eq!(at(72.0 + unit / 2.0), Some(RulerMark::Tick(5.0)));
+        assert_eq!(at(72.0 + unit / 8.0), Some(RulerMark::Tick(1.5)));
+        // Zoomed out, sub-half-inch ticks drop out rather than smudge together.
+        let coarse = ruler_marks(72.0, page_w, (unit, 8, 1), 0.3);
+        assert!(!coarse.iter().any(|(_, m)| matches!(m, RulerMark::Tick(1.5))));
+        assert!(coarse.iter().any(|(_, m)| matches!(m, RulerMark::Tick(3.0))));
+        // Laid on screen, the same ticks run the other way when mirrored.
+        let xs = |rtl| marks.iter().map(|(d, _)| ruler_x(*d, x0, scale, page_w, rtl)).collect::<Vec<_>>();
+        assert!(xs(false).windows(2).all(|w| w[0] < w[1]));
+        assert!(xs(true).windows(2).all(|w| w[0] > w[1]));
+    }
+
+    /// #692: Home › Paragraph › Right-to-Left Text Direction flips the ruler on screen: the
+    /// inch numbers mirror about the page's centre and rise right-to-left.
+    #[test]
+    fn setting_a_paragraph_rtl_mirrors_the_ruler_numbers() {
+        let ctx = egui::Context::default();
+        let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
+        a.run("text.insert", json!({"text": "Hello"})).unwrap();
+        let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1440.0, 900.0));
+        let mut t = 0.0;
+        // The horizontal ruler's inch labels: (text, centre x).
+        let mut labels = |a: &mut WordApp| {
+            t += 1.0 / 60.0;
+            let input = egui::RawInput { time: Some(t), screen_rect: Some(screen), ..Default::default() };
+            let out = ctx.run_ui(input, |ui| {
+                a.logic(ui.ctx());
+                a.ui(ui);
+            });
+            // The first frames only install fonts; the canvas appears after them.
+            let found = a.canvas.canvas_rect.as_ref().map_or_else(Vec::new, |area| {
+                // Ruler labels sit in the strip above the canvas, right of the vertical ruler.
+                out.shapes
+                    .iter()
+                    .filter_map(|clipped| match &clipped.shape {
+                        egui::Shape::Text(text) if text.pos.y >= area.min.y - RULER && text.pos.y < area.min.y && text.pos.x >= area.min.x => {
+                            Some((text.galley.text().to_owned(), text.pos.x + text.galley.size().x / 2.0))
+                        }
+                        _ => None,
+                    })
+                    .collect::<Vec<(String, f32)>>()
+            });
+            out.drop_without_applying_deltas();
+            found
+        };
+        let inch =
+            |labels: &[(String, f32)], n: &str| labels.iter().find(|(s, _)| s == n).map(|(_, x)| *x).unwrap_or_else(|| panic!("the ruler shows {n}"));
+        // The first frames install fonts and lay the page out.
+        for _ in 0..4 {
+            labels(&mut a);
+        }
+        let centre = a.canvas.page_rects[a.session.page_hint].center().x;
+        let before = labels(&mut a);
+        let (before1, before2) = (inch(&before, "1"), inch(&before, "2"));
+        assert!(before1 < centre && before1 < before2, "left to right: the numbers rise away from the left margin");
+
+        a.run("para.rtl", json!({})).unwrap();
+        let after = labels(&mut a);
+        let (after1, after2) = (inch(&after, "1"), inch(&after, "2"));
+        assert!(after1 > centre && after1 > after2, "right to left: the numbers rise away from the right margin");
+        assert!((after1 - (2.0 * centre - before1)).abs() < 1.0, "1 mirrors about the page centre: {before1} → {after1}");
+        assert!((after2 - (2.0 * centre - before2)).abs() < 1.0, "2 mirrors about the page centre: {before2} → {after2}");
+    }
+
+    #[test]
+    fn hiding_white_space_stacks_page_bands_and_keeps_hit_testing() {
+        let scale = 1.0;
+        let sizes = [(612.0, 792.0); 3];
+        let (rects, _) = place_pages(&sizes, 0.0, scale, 1, vec2(800.0, 600.0));
+        // Body from 72 to 720 pt on every page.
+        let bodies = [(72.0, 720.0); 3];
+        let (moved, bands, h) = collapse_white_space(&rects, &bodies, scale, 600.0);
+        assert_eq!(bands[0].0, 0.0, "first page keeps its top");
+        assert_eq!(bands[2].1, 792.0, "last page keeps its bottom");
+        assert_eq!(bands[1], (66.0, 726.0));
+        // Bands abut with one seam, so the content is much shorter than three full pages.
+        assert_eq!(moved[1].min.y + bands[1].0, moved[0].min.y + bands[0].1 + SEAM);
+        assert!(h < rects[2].bottom() - 2.0 * 66.0 * 2.0);
+        // A point inside page 2's band maps to that page and the right page coordinates.
+        let p = pos2(moved[1].center().x, moved[1].min.y + 300.0);
+        assert_eq!(page_at_index(&moved, p), Some(1));
+        // Just above the seam is page 1's text area, just below is page 2's, though the rects overlap.
+        let seam = moved[0].min.y + bands[0].1;
+        assert_eq!(nearest_page(&moved, pos2(moved[0].center().x, seam - 2.0)), Some(0));
+        assert_eq!(nearest_page(&moved, pos2(moved[0].center().x, seam + SEAM + 2.0)), Some(1));
+        assert!(on_page_gap(&moved, &bands, pos2(moved[0].center().x, seam + 0.5)));
+        assert!(!on_page_gap(&moved, &bands, pos2(moved[0].center().x, seam - 40.0)));
+        // Hostile numbers never panic.
+        let _ = collapse_white_space(&rects, &[(f32::NAN, f32::INFINITY), (-1e9, 1e9)], f32::NAN, f32::NAN);
+        let _ = collapse_white_space(&[], &[], 1.0, 1.0);
+    }
+
+    fn page_at_index(rects: &[Rect], p: Pos2) -> Option<usize> {
+        nearest_page(rects, p)
+    }
 }
diff --git a/crates/ui-egui/src/caret_glide.rs b/crates/ui-egui/src/caret_glide.rs
new file mode 100644
index 0000000000..0feb2b9713
--- /dev/null
+++ b/crates/ui-egui/src/caret_glide.rs
@@ -0,0 +1,877 @@
+//! The caret moves and blinks the way Word's does on Windows, instead of jumping and switching
+//! on and off.
+//!
+//! Measured from Word for Windows (version 16.0.20326, at 100% zoom on a 144 Hz display) as a
+//! user sees it: a synthetic document, Word's window captured frame by frame while keys, typing
+//! and clicks moved the caret. Nothing was read from the program. Word for Mac was not measured.
+//!
+//! - **A key or typing moves the caret:** it glides from where it was to its new place in
+//!   [`GLIDE_SECS`], fast at first and settling ([`ease`]). The time is the same for one
+//!   character and for a whole line.
+//! - **Another move before it arrives:** it snaps to where it was heading and glides from there.
+//! - **A click moves the caret:** no glide; it is drawn at its new place.
+//! - **A command from a script or the control channel:** no glide, no fade.
+//! - **The blink is a fade:** each time the caret turns on or off it takes [`GLIDE_SECS`] to get
+//!   there. A move by a key or a click turns it on the same way, from however visible it was, so
+//!   a caret that was off fades in while it glides.
+//!
+//! What never glides: a caret that moved because the view changed (zoom, a resized window,
+//! scrolling, another document), one that wasn't drawn the frame before (a selection, the canvas
+//! unfocused), and moves that start or end off screen. Our choice; Word wasn't measured there.
+//!
+//! With animations off the caret jumps and blinks on and off, as it always did: File ▸ Options ▸
+//! Advanced ▸ Animation (the `ui.caretAnimation` command) turns them off, and so do egui's
+//! `animation_time` at 0 (the headless test harness, so scripted screenshots never catch a caret
+//! in flight) and `WORDCRAFT_CARET_GLIDE_MS=0`. The variable also sets the duration, for looking
+//! at the motion slowed down.
+//!
+//! The glide runs in content space (screen points from the top-left of the scrolled content), so
+//! scrolling under a moving caret doesn't bend its path.
+
+use std::hash::{Hash, Hasher};
+
+use egui::{Pos2, Rect, Ui};
+
+use crate::WordApp;
+use crate::canvas::Geometry;
+
+/// How long a glide, and each fade of the blink, takes (seconds).
+pub const GLIDE_SECS: f64 = 0.10;
+/// The caret is on for this long, then off for this long (seconds).
+pub const BLINK_SECS: f64 = 0.53;
+/// The longest glide `WORDCRAFT_CARET_GLIDE_MS` can ask for.
+const MAX_GLIDE_SECS: f64 = 10.0;
+/// Moves shorter than this (screen points) aren't worth a glide.
+const MIN_MOVE: f32 = 0.5;
+/// How far outside the visible canvas a glide may start or end (screen points).
+const OFFSCREEN_SLACK: f32 = 48.0;
+
+/// The caret's bar: its two ends.
+pub type Bar = [Pos2; 2];
+
+/// What the canvas knows about the caret in one frame.
+#[derive(Clone, Copy, Debug)]
+pub struct Frame {
+    /// Where the caret belongs, in content space.
+    pub target: Bar,
+    /// Fingerprint of what puts the caret there: the document's revision and the selection.
+    pub cause: u64,
+    /// Fingerprint of how the document is shown: zoom, page arrangement, which document.
+    pub view: u64,
+    /// The caret is drawn this frame (the canvas has focus and nothing is selected).
+    pub shown: bool,
+    /// The part of content space on screen.
+    pub viewport: Rect,
+    /// egui's clock, in seconds.
+    pub now: f64,
+    /// egui's frame counter: a caret that skipped a frame doesn't glide from its stale place.
+    pub frame_nr: u64,
+    /// A key was pressed or text arrived this frame.
+    pub keys: bool,
+    /// A mouse button is down, or was pressed or released this frame.
+    pub pointer: bool,
+    /// Seconds since the blink was restarted (by the last command or click).
+    pub since_blink: f64,
+}
+
+/// How to draw the caret this frame.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub struct Look {
+    /// Where, in the space the target was given in.
+    pub bar: Bar,
+    /// How strongly: 0 (not at all) to 1.
+    pub opacity: f32,
+    /// It is gliding or fading in after a move: repaint every frame.
+    pub moving: bool,
+}
+
+#[derive(Clone, Copy, Debug)]
+struct Glide {
+    from: Bar,
+    to: Bar,
+    started: f64,
+}
+
+/// The caret turning on after a move, from however visible it was.
+#[derive(Clone, Copy, Debug)]
+struct FadeIn {
+    from: f32,
+    started: f64,
+}
+
+/// The caret's motion between frames. Time-based, so it looks the same at any frame rate.
+#[derive(Clone, Debug)]
+pub struct CaretGlide {
+    secs: f64,
+    /// Where the caret belonged last frame (content space); `None` when it wasn't drawn.
+    target: Option<Bar>,
+    /// Where and how strongly it was drawn last frame.
+    drawn: Option<Bar>,
+    opacity: f32,
+    glide: Option<Glide>,
+    fade: Option<FadeIn>,
+    /// A key or a mouse button was pressed last frame: the canvas handles its keys and its mouse
+    /// at the end of a frame, so the move they make is seen one frame later.
+    keys: bool,
+    pointer: bool,
+    cause: u64,
+    view: u64,
+    frame_nr: u64,
+}
+
+impl Default for CaretGlide {
+    fn default() -> Self {
+        CaretGlide::with_secs(glide_secs())
+    }
+}
+
+impl CaretGlide {
+    /// A caret whose glides and fades take `secs` seconds (0 or less: it jumps and blinks hard).
+    pub fn with_secs(secs: f64) -> Self {
+        let secs = if secs.is_finite() { secs.clamp(0.0, MAX_GLIDE_SECS) } else { GLIDE_SECS };
+        CaretGlide {
+            secs,
+            target: None,
+            drawn: None,
+            opacity: 0.0,
+            glide: None,
+            fade: None,
+            keys: false,
+            pointer: false,
+            cause: 0,
+            view: 0,
+            frame_nr: 0,
+        }
+    }
+
+    /// Advance to this frame; returns where and how strongly to draw the caret (content space).
+    pub fn frame(&mut self, f: Frame) -> Look {
+        let continuous = f.frame_nr.wrapping_sub(self.frame_nr) <= 1;
+        let was = self.target.filter(|_| continuous);
+        let was_opacity = if was.is_some() { self.opacity } else { 0.0 };
+        let edited = f.cause != self.cause;
+        let same_view = f.view == self.view;
+        let by_keys = f.keys || (self.keys && continuous);
+        let by_pointer = f.pointer || (self.pointer && continuous);
+        self.cause = f.cause;
+        self.view = f.view;
+        self.frame_nr = f.frame_nr;
+        self.keys = f.keys;
+        self.pointer = f.pointer;
+        let sane = is_finite(f.target) && f.now.is_finite();
+        if !(f.shown && sane) {
+            self.reset();
+            return Look { bar: f.target, opacity: 0.0, moving: false };
+        }
+        if self.secs <= 0.0 {
+            // Animations off: in place, and on or off.
+            self.glide = None;
+            self.fade = None;
+            let opacity = if blink(f.since_blink, 0.0) > 0.5 { 1.0 } else { 0.0 };
+            return self.draw(f.target, f.target, opacity);
+        }
+        if !same_view {
+            self.glide = None;
+        }
+        // Where the caret was heading: its place last frame, or the end of the glide under way.
+        let heading = self.glide.map(|g| g.to).or(was);
+        let moved = heading.is_none_or(|h| distance(h, f.target) >= MIN_MOVE);
+        if edited && moved && (by_keys || by_pointer) {
+            // A key or a click turns the caret on, from however visible it was.
+            self.fade = Some(FadeIn { from: was_opacity, started: f.now });
+            self.glide = match heading {
+                // Keys glide, from where the caret was heading (not from where it has got to).
+                Some(from) if by_keys && !by_pointer && same_view => {
+                    let seen = f.viewport.expand(OFFSCREEN_SLACK);
+                    let on_screen = |b: Bar| seen.intersects(Rect::from_two_pos(b[0], b[1]));
+                    (on_screen(from) && on_screen(f.target)).then_some(Glide { from, to: f.target, started: f.now })
+                }
+                _ => None,
+            };
+        } else if edited && moved {
+            // A script moved it: it is simply there.
+            self.glide = None;
+            self.fade = None;
+        }
+        // The text shifted under a glide (pixel snapping while scrolling): carry the glide along.
+        if let Some(g) = &mut self.glide
+            && g.to != f.target
+        {
+            let d = f.target[0] - g.to[0];
+            g.from = [g.from[0] + d, g.from[1] + d];
+            g.to = f.target;
+        }
+        let bar = match self.glide {
+            Some(g) => match progress(f.now, g.started, self.secs) {
+                Some(s) => lerp(g.from, g.to, ease(s)),
+                None => {
+                    self.glide = None;
+                    f.target
+                }
+            },
+            None => f.target,
+        };
+        let opacity = match self.fade {
+            Some(fade) => match progress(f.now, fade.started, self.secs) {
+                Some(s) => fade.from + (1.0 - fade.from) * s,
+                None => {
+                    self.fade = None;
+                    1.0
+                }
+            },
+            // A gliding caret stays lit; a resting one blinks.
+            None if self.glide.is_some() => 1.0,
+            None => blink(f.since_blink, self.secs),
+        };
+        self.draw(f.target, bar, opacity)
+    }
+
+    fn draw(&mut self, target: Bar, bar: Bar, opacity: f32) -> Look {
+        let opacity = if opacity.is_finite() { opacity.clamp(0.0, 1.0) } else { 1.0 };
+        self.target = Some(target);
+        self.drawn = Some(bar);
+        self.opacity = opacity;
+        Look { bar, opacity, moving: self.glide.is_some() || self.fade.is_some() }
+    }
+
+    /// The caret is on its way somewhere.
+    pub fn is_gliding(&self) -> bool {
+        self.glide.is_some()
+    }
+
+    /// Where the caret was drawn last frame (content space), if it was drawn.
+    pub fn drawn(&self) -> Option<Bar> {
+        self.drawn
+    }
+
+    /// How strongly the caret was drawn last frame (0 when it wasn't).
+    pub fn opacity(&self) -> f32 {
+        self.opacity
+    }
+
+    /// Forget the caret: it appears wherever it belongs next frame.
+    pub fn reset(&mut self) {
+        self.glide = None;
+        self.fade = None;
+        self.target = None;
+        self.drawn = None;
+        self.opacity = 0.0;
+    }
+}
+
+/// How far along an animation that started at `started` and lasts `secs` is at `now`: 0 to 1, or
+/// `None` once it is over (or the clock went backwards).
+fn progress(now: f64, started: f64, secs: f64) -> Option<f32> {
+    let s = (now - started) / secs;
+    (0.0..1.0).contains(&s).then_some(s as f32)
+}
+
+/// Word's curve for the glide, `cubic-bezier(0, 0, 0, 1)`: more than a third of the way after
+/// 7% of the time, nine tenths after half of it. For these control points the curve has a closed
+/// form: time is `u³` and distance `3u² − 2u³`.
+pub fn ease(s: f32) -> f32 {
+    let s = if s.is_finite() { s.clamp(0.0, 1.0) } else { 1.0 };
+    3.0 * s.powf(2.0 / 3.0) - 2.0 * s
+}
+
+/// A resting caret's opacity `since` seconds after its blink was restarted: on for
+/// [`BLINK_SECS`], off for as long, and so on, taking `fade` seconds over each change (the first
+/// turn-on isn't faded here: the move that restarted the blink does that).
+pub fn blink(since: f64, fade: f64) -> f32 {
+    if !since.is_finite() || since < BLINK_SECS {
+        return 1.0;
+    }
+    let phase = since % (2.0 * BLINK_SECS);
+    let (into, turning_on) = if phase < BLINK_SECS { (phase, true) } else { (phase - BLINK_SECS, false) };
+    let done = if fade > 0.0 { (into / fade).clamp(0.0, 1.0) as f32 } else { 1.0 };
+    if turning_on { done } else { 1.0 - done }
+}
+
+/// The blink is part-way through a fade: keep repainting.
+fn blink_fading(since: f64, fade: f64) -> bool {
+    since.is_finite() && since >= BLINK_SECS && (since % BLINK_SECS) < fade
+}
+
+fn lerp(a: Bar, b: Bar, t: f32) -> Bar {
+    [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]
+}
+
+/// How far the bar's farthest end moves.
+fn distance(a: Bar, b: Bar) -> f32 {
+    (b[0] - a[0]).length().max((b[1] - a[1]).length())
+}
+
+fn is_finite(b: Bar) -> bool {
+    b[0].x.is_finite() && b[0].y.is_finite() && b[1].x.is_finite() && b[1].y.is_finite()
+}
+
+/// The glide's duration: [`GLIDE_SECS`], or `WORDCRAFT_CARET_GLIDE_MS` when set (tests ignore it).
+fn glide_secs() -> f64 {
+    if cfg!(test) {
+        return GLIDE_SECS;
+    }
+    static SECS: std::sync::OnceLock<f64> = std::sync::OnceLock::new();
+    *SECS.get_or_init(|| parse_ms(std::env::var("WORDCRAFT_CARET_GLIDE_MS").ok().as_deref()))
+}
+
+fn parse_ms(value: Option<&str>) -> f64 {
+    match value.and_then(|s| s.trim().parse::<f64>().ok()) {
+        Some(ms) if ms.is_finite() => (ms / 1000.0).clamp(0.0, MAX_GLIDE_SECS),
+        _ => GLIDE_SECS,
+    }
+}
+
+fn state_id() -> egui::Id {
+    egui::Id::new("caret_glide")
+}
+
+/// What puts the caret where it is: the document's revision and the caret's position in it.
+fn cause_key(app: &WordApp) -> u64 {
+    let s = &app.session;
+    let mut h = std::collections::hash_map::DefaultHasher::new();
+    (s.rev(), &s.sel.focus).hash(&mut h);
+    if let Some(m) = &s.math {
+        format!("{:?}", m.pos).hash(&mut h);
+    }
+    h.finish()
+}
+
+/// How the document is shown: which document, the zoom and where the pages sit.
+fn view_key(app: &WordApp, geo: &Geometry) -> u64 {
+    let mut h = std::collections::hash_map::DefaultHasher::new();
+    (app.session.document_id(), geo.scale.to_bits(), geo.cols, geo.size.x.to_bits()).hash(&mut h);
+    geo.rects.first().map(|r| (r.min.x.to_bits(), r.min.y.to_bits())).hash(&mut h);
+    h.finish()
+}
+
+/// The canvas's hook: `target` is where the caret belongs on screen this frame, `shown` whether
+/// it is drawn at all, `since_ms` how long ago its blink was restarted and `on` what the plain
+/// on-and-off blink says. Returns where and how strongly to draw it. `content_origin` is the scrolled
+/// content's top-left on screen.
+pub fn look(app: &WordApp, ui: &Ui, content_origin: Pos2, geo: &Geometry, target: Bar, shown: bool, since_ms: f64, on: bool) -> Look {
+    // Turned off in Options, Animation effects off (the setting, or the system's under "Use system
+    // setting"), or egui's own switch for "no animations": the caret jumps and blinks on and off.
+    if !app.ui.caret_animation || !app.animations_on() || ui.style().animation_time <= 0.0 || glide_secs() <= 0.0 {
+        ui.ctx().data_mut(|d| d.get_temp_mut_or_default::<CaretGlide>(state_id()).reset());
+        return Look { bar: target, opacity: if on { 1.0 } else { 0.0 }, moving: false };
+    }
+    let off = content_origin.to_vec2();
+    let since = since_ms / 1000.0;
+    let (keys, pointer, now) = ui.input(|i| {
+        let typed = |e: &egui::Event| {
+            matches!(e, egui::Event::Key { pressed: true, .. } | egui::Event::Text(_) | egui::Event::Paste(_) | egui::Event::Ime(_))
+        };
+        (i.events.iter().any(typed), i.pointer.any_down() || i.pointer.any_pressed() || i.pointer.any_released(), i.time)
+    });
+    let frame = Frame {
+        target: [target[0] - off, target[1] - off],
+        cause: cause_key(app),
+        view: view_key(app, geo),
+        shown,
+        viewport: ui.clip_rect().translate(-off),
+        now,
+        frame_nr: ui.ctx().cumulative_frame_nr(),
+        keys,
+        pointer,
+        since_blink: since,
+    };
+    let (mut look, gliding, secs) = ui.ctx().data_mut(|d| {
+        let state = d.get_temp_mut_or_default::<CaretGlide>(state_id());
+        (state.frame(frame), state.is_gliding(), state.secs)
+    });
+    // At rest the caller's own pixel-snapped bar is drawn, untouched.
+    look.bar = if gliding { [look.bar[0] + off, look.bar[1] + off] } else { target };
+    if look.moving {
+        ui.ctx().request_repaint();
+    } else if shown && blink_fading(since, secs) {
+        // The blink's fade needs a handful of frames, not every one.
+        ui.ctx().request_repaint_after(std::time::Duration::from_millis(16));
+    }
+    look
+}
+
+/// The caret's glide state this frame (for tests and tools).
+pub fn state(ctx: &egui::Context) -> CaretGlide {
+    ctx.data(|d| d.get_temp::<CaretGlide>(state_id())).unwrap_or_default()
+}
+
+#[cfg(test)]
+mod tests {
+    use egui::{pos2, vec2};
+    use serde_json::json;
+
+    use super::*;
+
+    const DT: f64 = 1.0 / 60.0;
+
+    fn bar(x: f32, y: f32) -> Bar {
+        [pos2(x, y), pos2(x, y + 16.0)]
+    }
+
+    /// A caret driven frame by frame, with the bookkeeping a canvas would do.
+    struct Rig {
+        glide: CaretGlide,
+        f: Frame,
+        /// When the blink was last restarted.
+        restarted: f64,
+    }
+
+    impl Rig {
+        fn new(at: Bar) -> Self {
+            let f = Frame {
+                target: at,
+                cause: 1,
+                view: 1,
+                shown: true,
+                viewport: Rect::from_min_size(pos2(0.0, 0.0), vec2(1000.0, 800.0)),
+                now: 100.0,
+                frame_nr: 10,
+                keys: false,
+                pointer: false,
+                since_blink: 0.0,
+            };
+            let mut rig = Rig { glide: CaretGlide::with_secs(GLIDE_SECS), f, restarted: 100.0 };
+            assert_eq!(rig.glide.frame(rig.f), Look { bar: at, opacity: 1.0, moving: false }, "the first frame draws the caret in place");
+            rig
+        }
+
+        /// The next frame, `dt` seconds later. Input lasts one frame.
+        fn step(&mut self, dt: f64) -> Look {
+            self.f.now += dt;
+            self.f.frame_nr += 1;
+            self.f.since_blink = self.f.now - self.restarted;
+            let look = self.glide.frame(self.f);
+            self.f.keys = false;
+            self.f.pointer = false;
+            look
+        }
+
+        /// A key (arrow, typing) moves the caret: the command restarts the blink.
+        fn key_to(&mut self, to: Bar) {
+            self.f.target = to;
+            self.f.cause += 1;
+            self.f.keys = true;
+            self.restarted = self.f.now + DT;
+        }
+
+        /// A script or the control channel moves the caret.
+        fn script_to(&mut self, to: Bar) {
+            self.f.target = to;
+            self.f.cause += 1;
+            self.restarted = self.f.now + DT;
+        }
+
+        /// A click moves the caret. The canvas handles the mouse at the end of its frame, so the
+        /// button is seen a frame before the caret moves.
+        fn click_to(&mut self, to: Bar) {
+            self.f.pointer = true;
+            self.step(DT);
+            self.f.target = to;
+            self.f.cause += 1;
+            self.restarted = self.f.now + DT;
+        }
+
+        /// Let `secs` pass at rest.
+        fn rest(&mut self, secs: f64) -> Look {
+            let mut look = self.step(DT);
+            for _ in 1..(secs / DT).round() as usize {
+                look = self.step(DT);
+            }
+            look
+        }
+    }
+
+    /// The curve is Word's: these are the caret's measured places, frame by frame at 144 Hz, as
+    /// fractions of the way (the same for moves of 6 px and of 372 px).
+    #[test]
+    fn the_glide_follows_words_measured_curve() {
+        let measured = [0.369, 0.529, 0.640, 0.724, 0.790, 0.843, 0.885, 0.918, 0.945, 0.965, 0.980, 0.991, 0.997, 1.0];
+        for (k, want) in measured.iter().enumerate() {
+            let s = (k + 1) as f32 * (1.0 / 144.0) / GLIDE_SECS as f32;
+            assert!((ease(s) - want).abs() < 0.004, "frame {}: {} vs measured {want}", k + 1, ease(s));
+        }
+        assert_eq!((ease(0.0), ease(1.0)), (0.0, 1.0));
+        assert!(ease(0.5) > 0.88, "nine tenths of the way in half the time");
+        assert_eq!((ease(-3.0), ease(7.0), ease(f32::NAN)), (0.0, 1.0, 1.0));
+        let mut last = 0.0;
+        for i in 0..=1000 {
+            let p = ease(i as f32 / 1000.0);
+            assert!(p >= last && p <= 1.0, "never backwards, never past the end");
+            last = p;
+        }
+    }
+
+    #[test]
+    fn a_key_move_glides_and_lands_exactly() {
+        let mut r = Rig::new(bar(100.0, 50.0));
+        r.key_to(bar(200.0, 90.0));
+        let first = r.step(DT);
+        assert_eq!(first.bar, bar(100.0, 50.0), "the glide starts from where the caret was");
+        assert!(first.moving && r.glide.is_gliding());
+        let mut last = 100.0;
+        let mut frames = 0;
+        while r.glide.is_gliding() {
+            let look = r.step(DT);
+            let b = look.bar;
+            assert!(b[0].x >= last && b[0].x <= 200.0, "moves toward the target without overshooting: {b:?}");
+            assert!((b[1].y - b[0].y - 16.0).abs() < 1e-3, "the bar keeps its height: {b:?}");
+            assert_eq!(look.opacity, 1.0, "a caret that was lit stays lit on the way");
+            last = b[0].x;
+            frames += 1;
+            assert!(frames < 60);
+        }
+        assert_eq!(r.glide.drawn(), Some(bar(200.0, 90.0)));
+        // 0.1 s at 60 Hz.
+        assert!((5..=7).contains(&frames), "{frames} frames");
+        assert_eq!(r.step(DT), Look { bar: bar(200.0, 90.0), opacity: 1.0, moving: false }, "then it rests");
+    }
+
+    #[test]
+    fn the_glide_is_the_same_at_any_frame_rate() {
+        let at = |hz: f64| {
+            let mut r = Rig::new(bar(0.0, 0.0));
+            r.key_to(bar(300.0, 0.0));
+            r.step(1.0 / hz);
+            let mut b = bar(0.0, 0.0);
+            // 0.05 s in: three frames at 60 Hz, twelve at 240 Hz.
+            for _ in 0..(hz / 20.0).round() as usize {
+                b = r.step(1.0 / hz).bar;
+            }
+            b[0].x
+        };
+        let expected = 300.0 * ease((0.05 / GLIDE_SECS) as f32);
+        assert!((at(60.0) - expected).abs() < 0.5, "{} vs {expected}", at(60.0));
+        assert!((at(240.0) - expected).abs() < 0.5, "{} vs {expected}", at(240.0));
+    }
+
+    /// Word: a second key before the caret arrives makes it snap to where it was heading and set
+    /// off from there (held arrow keys, quick typing).
+    #[test]
+    fn a_new_key_move_sets_off_from_where_the_caret_was_heading() {
+        let mut r = Rig::new(bar(0.0, 0.0));
+        r.key_to(bar(100.0, 0.0));
+        r.step(DT);
+        let mid = r.step(DT * 2.0).bar;
+        assert!(mid[0].x > 0.0 && mid[0].x < 100.0);
+        r.key_to(bar(110.0, 0.0));
+        assert_eq!(r.step(DT).bar, bar(100.0, 0.0), "it snaps to the first move's end");
+        let next = r.step(DT).bar;
+        assert!(next[0].x > 100.0 && next[0].x < 110.0);
+        r.rest(0.2);
+        assert_eq!(r.glide.drawn(), Some(bar(110.0, 0.0)));
+        assert!(!r.glide.is_gliding());
+        // Something else changed the document but left the caret alone: nothing to do.
+        r.f.cause += 1;
+        r.f.keys = true;
+        assert_eq!(r.step(DT).bar, bar(110.0, 0.0));
+        assert!(!r.glide.is_gliding());
+        // The canvas reads its keys at the end of a frame: the move shows up one frame after the
+        // key, and still glides. Two frames after, it is somebody else's move.
+        r.rest(0.2);
+        r.f.keys = true;
+        r.step(DT);
+        r.f.target = bar(160.0, 0.0);
+        r.f.cause += 1;
+        assert_eq!(r.step(DT).bar, bar(110.0, 0.0));
+        assert!(r.glide.is_gliding());
+        r.rest(0.2);
+        r.f.keys = true;
+        r.step(DT);
+        r.step(DT);
+        r.f.target = bar(210.0, 0.0);
+        r.f.cause += 1;
+        assert_eq!(r.step(DT).bar, bar(210.0, 0.0));
+        assert!(!r.glide.is_gliding());
+    }
+
+    /// Word: a click puts the caret where it was clicked, a script's move likewise; only keys glide.
+    #[test]
+    fn clicks_and_scripts_do_not_glide() {
+        let mut r = Rig::new(bar(100.0, 100.0));
+        r.click_to(bar(400.0, 300.0));
+        let look = r.step(DT);
+        assert_eq!(look.bar, bar(400.0, 300.0));
+        assert!(!r.glide.is_gliding());
+        assert_eq!(look.opacity, 1.0, "a lit caret stays lit");
+        r.rest(0.2);
+        r.script_to(bar(50.0, 50.0));
+        assert_eq!(r.step(DT), Look { bar: bar(50.0, 50.0), opacity: 1.0, moving: false });
+        // A script's move during a glide ends the glide.
+        r.key_to(bar(250.0, 50.0));
+        r.step(DT);
+        r.step(DT);
+        assert!(r.glide.is_gliding());
+        r.script_to(bar(20.0, 20.0));
+        assert_eq!(r.step(DT), Look { bar: bar(20.0, 20.0), opacity: 1.0, moving: false });
+        // A click during a glide too.
+        r.key_to(bar(250.0, 20.0));
+        r.step(DT);
+        r.click_to(bar(300.0, 300.0));
+        assert_eq!(r.step(DT).bar, bar(300.0, 300.0));
+        assert!(!r.glide.is_gliding());
+    }
+
+    /// Word: the blink is a fade, and a move turns the caret on from however visible it was.
+    #[test]
+    fn the_blink_fades_and_a_move_turns_the_caret_on() {
+        // On for 0.53 s, a 0.1 s fade out, off, a 0.1 s fade in.
+        assert_eq!((blink(0.0, 0.1), blink(0.3, 0.1), blink(0.529, 0.1)), (1.0, 1.0, 1.0));
+        assert!((blink(0.58, 0.1) - 0.5).abs() < 0.01);
+        assert_eq!((blink(0.64, 0.1), blink(1.0, 0.1)), (0.0, 0.0));
+        assert!((blink(1.06 + 0.025, 0.1) - 0.25).abs() < 0.01);
+        assert_eq!(blink(1.3, 0.1), 1.0);
+        assert!((blink(1.59 + 0.075, 0.1) - 0.25).abs() < 0.01);
+        assert!(blink_fading(0.55, 0.1) && blink_fading(1.1, 0.1) && !blink_fading(0.3, 0.1) && !blink_fading(0.8, 0.1) && !blink_fading(0.05, 0.1));
+        // With no fade it is the plain on-and-off blink.
+        assert_eq!((blink(0.52, 0.0), blink(0.54, 0.0), blink(1.05, 0.0), blink(1.07, 0.0)), (1.0, 0.0, 0.0, 1.0));
+        assert_eq!((blink(f64::NAN, 0.1), blink(-5.0, 0.1), blink(f64::INFINITY, 0.1)), (1.0, 1.0, 1.0));
+
+        // At rest the caret fades out and back in.
+        let mut r = Rig::new(bar(100.0, 100.0));
+        assert_eq!(r.rest(0.4).opacity, 1.0);
+        let fading = r.rest(0.18).opacity;
+        assert!(fading > 0.2 && fading < 0.8, "half-way through the fade out: {fading}");
+        assert_eq!(r.rest(0.2).opacity, 0.0);
+        // A key while it is off: it fades in over the glide, evenly.
+        r.key_to(bar(200.0, 100.0));
+        let mut seen = vec![r.step(DT).opacity];
+        while r.glide.is_gliding() {
+            seen.push(r.step(DT).opacity);
+        }
+        assert_eq!((seen[0], seen[seen.len() - 1]), (0.0, 1.0));
+        assert!(seen.windows(2).all(|w| w[1] >= w[0]) && seen[1] > 0.1 && seen[2] > seen[1], "{seen:?}");
+        assert!((seen[3] - 0.5).abs() < 0.02, "half lit half-way: {seen:?}");
+        assert_eq!(r.step(DT).opacity, 1.0);
+        // A click while it is off fades in too, in place.
+        r.rest(0.8);
+        assert_eq!(r.glide.opacity(), 0.0);
+        r.click_to(bar(300.0, 200.0));
+        let look = r.step(DT);
+        assert_eq!((look.bar, look.opacity, look.moving), (bar(300.0, 200.0), 0.0, true));
+        let look = r.rest(0.05);
+        assert!(look.opacity > 0.3 && look.opacity < 0.7 && look.bar == bar(300.0, 200.0), "{look:?}");
+        assert_eq!(r.rest(0.1).opacity, 1.0);
+        // A script's move while it is off: lit at once.
+        r.rest(0.7);
+        assert_eq!(r.glide.opacity(), 0.0);
+        r.script_to(bar(10.0, 10.0));
+        assert_eq!(r.step(DT), Look { bar: bar(10.0, 10.0), opacity: 1.0, moving: false });
+        // A key while it is half faded: on from there.
+        r.rest(0.56);
+        let half = r.glide.opacity();
+        assert!(half > 0.1 && half < 0.9, "{half}");
+        r.key_to(bar(60.0, 10.0));
+        assert!((r.step(DT).opacity - half).abs() < 1e-6);
+        assert!(r.step(DT).opacity > half);
+    }
+
+    #[test]
+    fn view_changes_and_scrolling_never_glide() {
+        // Zoom or a resized window: the caret stays glued to its text.
+        let mut r = Rig::new(bar(100.0, 100.0));
+        r.f.target = bar(180.0, 150.0);
+        r.f.view += 1;
+        assert_eq!(r.step(DT).bar, bar(180.0, 150.0));
+        assert!(!r.glide.is_gliding());
+        // …even when a key press in the same frame also moved the caret.
+        r.key_to(bar(40.0, 40.0));
+        r.f.view += 1;
+        assert_eq!(r.step(DT).bar, bar(40.0, 40.0));
+        assert!(!r.glide.is_gliding());
+        r.rest(0.2);
+        // The target shifting with nothing edited (pixel snapping while scrolling) is followed.
+        r.f.target = bar(40.4, 40.0);
+        assert_eq!(r.step(DT).bar, bar(40.4, 40.0));
+        assert!(!r.glide.is_gliding());
+        // The same shift under a glide moves the whole glide; it doesn't restart it.
+        r.key_to(bar(140.0, 40.0));
+        r.step(DT);
+        let before = r.step(DT).bar;
+        r.f.target = bar(140.0, 40.5);
+        let after = r.step(DT).bar;
+        assert!(after[0].x > before[0].x && (after[0].y - 40.5).abs() < 1e-3, "{after:?}");
+        r.rest(0.2);
+        assert_eq!(r.glide.drawn(), Some(bar(140.0, 40.5)));
+        // A view change during a glide ends it.
+        r.key_to(bar(340.0, 40.5));
+        r.step(DT);
+        r.step(DT);
+        r.f.view += 1;
+        assert_eq!(r.step(DT).bar, bar(340.0, 40.5));
+        assert!(!r.glide.is_gliding());
+    }
+
+    #[test]
+    fn a_hidden_stale_or_off_screen_caret_appears_in_place() {
+        // Hidden (a selection, or the canvas lost focus), then back somewhere else.
+        let mut r = Rig::new(bar(100.0, 100.0));
+        r.f.shown = false;
+        r.key_to(bar(300.0, 100.0));
+        assert_eq!(r.step(DT).opacity, 0.0);
+        assert_eq!(r.glide.drawn(), None);
+        r.f.shown = true;
+        r.key_to(bar(500.0, 100.0));
+        let look = r.step(DT);
+        assert_eq!(look.bar, bar(500.0, 100.0));
+        assert!(!r.glide.is_gliding() && look.moving, "it fades in where it is");
+        r.rest(0.2);
+        // The canvas skipped frames (Backstage open): no glide from the stale place.
+        r.f.frame_nr += 30;
+        r.key_to(bar(200.0, 100.0));
+        assert_eq!(r.step(DT).bar, bar(200.0, 100.0));
+        assert!(!r.glide.is_gliding());
+        r.rest(0.2);
+        // A jump to somewhere off screen (Ctrl+End), and back from there.
+        r.key_to(bar(200.0, 5000.0));
+        assert_eq!(r.step(DT).bar, bar(200.0, 5000.0));
+        assert!(!r.glide.is_gliding());
+        r.key_to(bar(200.0, 100.0));
+        assert_eq!(r.step(DT).bar, bar(200.0, 100.0));
+        assert!(!r.glide.is_gliding());
+        r.rest(0.2);
+        // Just past the edge (the next line while the view scrolls to it) still glides.
+        r.key_to(bar(200.0, 810.0));
+        r.step(DT);
+        assert!(r.glide.is_gliding());
+    }
+
+    #[test]
+    fn turned_off_or_hostile_numbers_never_glide_or_panic() {
+        // Off: it jumps, and blinks hard.
+        let mut off = Rig::new(bar(0.0, 0.0));
+        off.glide = CaretGlide::with_secs(0.0);
+        off.step(DT);
+        off.key_to(bar(90.0, 0.0));
+        assert_eq!(off.step(DT), Look { bar: bar(90.0, 0.0), opacity: 1.0, moving: false });
+        assert_eq!(off.rest(0.5).opacity, 1.0);
+        assert_eq!(off.rest(0.06).opacity, 0.0);
+        assert_eq!(off.rest(0.5).opacity, 1.0);
+
+        assert_eq!(CaretGlide::with_secs(f64::NAN).secs, GLIDE_SECS);
+        assert_eq!(CaretGlide::with_secs(-3.0).secs, 0.0);
+        assert_eq!(CaretGlide::with_secs(f64::INFINITY).secs, GLIDE_SECS);
+        assert_eq!(parse_ms(None), GLIDE_SECS);
+        assert_eq!(parse_ms(Some("junk")), GLIDE_SECS);
+        assert_eq!(parse_ms(Some("NaN")), GLIDE_SECS);
+        assert_eq!(parse_ms(Some(" 0 ")), 0.0);
+        assert_eq!(parse_ms(Some("-5")), 0.0);
+        assert_eq!(parse_ms(Some("250")), 0.25);
+        assert_eq!(parse_ms(Some("1e300")), MAX_GLIDE_SECS);
+
+        let mut r = Rig::new(bar(10.0, 10.0));
+        let junk = [pos2(f32::NAN, f32::INFINITY), pos2(f32::NEG_INFINITY, 0.0)];
+        r.key_to(junk);
+        assert_eq!(r.step(DT).opacity, 0.0);
+        assert!(!r.glide.is_gliding() && r.glide.drawn().is_none());
+        r.key_to(bar(50.0, 10.0));
+        assert_eq!(r.step(DT).bar, bar(50.0, 10.0), "back from junk: in place");
+        r.rest(0.2);
+        // The clock stops, jumps back or goes bad mid-glide.
+        r.key_to(bar(150.0, 10.0));
+        r.step(DT);
+        assert!(is_finite(r.step(0.0).bar));
+        assert_eq!(r.step(-50.0).bar, bar(150.0, 10.0));
+        r.key_to(bar(250.0, 10.0));
+        r.step(DT);
+        assert_eq!(r.step(f64::NAN).opacity, 0.0, "a bad clock: nothing is drawn that frame");
+        r.f.now = 200.0;
+        r.key_to(bar(350.0, 10.0));
+        r.step(DT);
+        r.step(f64::INFINITY);
+        // A blink clock gone bad leaves the caret lit.
+        let mut r = Rig::new(bar(0.0, 0.0));
+        r.restarted = f64::NAN;
+        let look = r.step(DT);
+        assert!(look.opacity == 1.0 && is_finite(look.bar));
+        r.restarted = f64::INFINITY;
+        assert_eq!(r.step(DT).opacity, 1.0);
+        // Coordinates at the edge of f32.
+        let mut r = Rig::new(bar(0.0, 0.0));
+        r.f.viewport = Rect::EVERYTHING;
+        r.key_to(bar(f32::MAX, 0.0));
+        r.step(DT);
+        for _ in 0..12 {
+            let look = r.step(DT);
+            assert!((0.0..=1.0).contains(&look.opacity));
+        }
+        r.glide.reset();
+        assert!(r.glide.drawn().is_none() && !r.glide.is_gliding() && r.glide.opacity() == 0.0);
+    }
+
+    fn key(key: egui::Key) -> egui::Event {
+        egui::Event::Key { key, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() }
+    }
+
+    /// The whole path: a key in the real app glides the drawn caret across the canvas; a command
+    /// run by a script and a change of zoom don't.
+    #[test]
+    fn the_canvas_caret_glides_after_a_key() {
+        let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
+        a.run("text.insert", json!({"text": "Some text here"})).unwrap();
+        // Animation effects off: the caret follows that switch.
+        a.run("ui.animations", json!({"value": "off"})).unwrap();
+        let mut h = egui_kittest::Harness::builder().with_size(vec2(1440.0, 900.0)).with_step_dt(DT as f32).build_ui_state(
+            |ui, app: &mut WordApp| {
+                let ctx = ui.ctx().clone();
+                app.logic(&ctx);
+                app.ui(ui);
+            },
+            a,
+        );
+        for _ in 0..3 {
+            h.step();
+        }
+        assert!(state(&h.ctx).drawn().is_none(), "no animations: the glide stands down");
+        h.state_mut().run("ui.animations", json!({"value": "on"})).unwrap();
+        h.ctx.all_styles_mut(|s| s.animation_time = 0.1);
+        for _ in 0..30 {
+            h.step();
+        }
+        let near = |a: Bar, b: Bar| distance(a, b) < 0.01;
+        let end = state(&h.ctx).drawn().expect("the focused canvas draws a caret");
+        assert!(!state(&h.ctx).is_gliding());
+        // Home: the caret glides to the start of the line.
+        // (The canvas reads the key at the end of its frame; the caret sets off in the next.)
+        h.event(key(egui::Key::Home));
+        for _ in 0..3 {
+            h.step();
+        }
+        let mid = state(&h.ctx);
+        assert!(mid.is_gliding(), "the caret is on its way");
+        let x = mid.drawn().unwrap()[0].x;
+        for _ in 0..20 {
+            h.step();
+        }
+        let start = state(&h.ctx).drawn().unwrap();
+        assert!(!state(&h.ctx).is_gliding(), "and comes to rest");
+        assert_eq!(h.state().session.sel.focus.off, 0, "Home moved the caret");
+        assert!(start[0].x + 20.0 < end[0].x, "to the start of the line: {start:?} from {end:?}");
+        assert!(x > start[0].x && x < end[0].x, "on the way it was drawn in between: {x}");
+        // A command run by a script puts it there at once.
+        h.state_mut().run("caret.docEnd", json!({})).unwrap();
+        h.step();
+        assert!(!state(&h.ctx).is_gliding());
+        assert!(near(state(&h.ctx).drawn().unwrap(), end), "back at the end of the text");
+        // Zooming moves the caret on screen but doesn't glide it.
+        h.state_mut().run("view.zoom", json!({"value": 150})).unwrap();
+        for _ in 0..3 {
+            h.step();
+            assert!(!state(&h.ctx).is_gliding());
+        }
+        assert!(!near(state(&h.ctx).drawn().unwrap(), end));
+        // Turned off in Options: the caret jumps.
+        h.state_mut().run("ui.caretAnimation", json!({"value": false})).unwrap();
+        h.step();
+        assert!(state(&h.ctx).drawn().is_none(), "the animation stands down");
+        h.event(key(egui::Key::Home));
+        for _ in 0..3 {
+            h.step();
+            assert!(!state(&h.ctx).is_gliding());
+        }
+        assert_eq!(h.state().session.sel.focus.off, 0, "Home still moved the caret");
+        // And on again.
+        h.state_mut().run("ui.caretAnimation", json!({"value": true})).unwrap();
+        h.step();
+        assert!(state(&h.ctx).drawn().is_some());
+    }
+}
diff --git a/crates/ui-egui/src/chrome.rs b/crates/ui-egui/src/chrome.rs
index 79bc72b5eb..f0dd42458f 100644
--- a/crates/ui-egui/src/chrome.rs
+++ b/crates/ui-egui/src/chrome.rs
@@ -132,7 +132,7 @@ pub fn title_bar(app: &mut WordApp, ui: &mut Ui) {
                 let (r, resp) = ui.allocate_exact_size(vec2(30.0, 16.0), Sense::click());
                 let (fill, stroke, knob_fill) = match (&block, on) {
                     (Some(_), _) => (t.input.gamma_multiply(0.5), t.border.gamma_multiply(0.7), t.text_dim.gamma_multiply(0.45)),
-                    (None, true) => (t.accent, t.accent, egui::Color32::WHITE),
+                    (None, true) => (t.accent, t.accent, t.on_accent),
                     (None, false) => (t.input, t.border_strong, t.text_dim),
                 };
                 ui.painter().rect(r, 8.0, fill, Stroke::new(1.0, stroke), egui::StrokeKind::Inside);
@@ -160,8 +160,8 @@ pub fn title_bar(app: &mut WordApp, ui: &mut Ui) {
                     // Account / community.
                     let (r, resp) = ui.allocate_exact_size(vec2(control_h, control_h), Sense::click());
                     ui.painter().circle_filled(r.center(), control_h / 2.0 - 1.0, t.accent);
-                    let initials: String = app.session.author.split_whitespace().filter_map(|w| w.chars().next()).take(2).collect();
-                    ui.painter().text(r.center(), Align2::CENTER_CENTER, initials, semibold(10.5), egui::Color32::WHITE);
+                    let initials: String = app.session.user_initials().chars().take(2).collect();
+                    ui.painter().text(r.center(), Align2::CENTER_CENTER, initials, semibold(10.5), t.on_accent);
                     resp.on_hover_text(format!("{} — set your name in File › Options", app.session.author));
                     ui.add_space(8.0);
                     if app.ui.show_discord {
@@ -301,6 +301,9 @@ pub fn status_bar(app: &mut WordApp, ui: &mut Ui) {
                 if app.session.doc.settings.track_changes {
                     st(ui, tl!("Track Changes: On"));
                 }
+                if app.session.prefs.overtype && st(ui, tl!("Overtype")).on_hover_text(tl!("Click to switch back to inserting")).clicked() {
+                    let _ = app.run("text.overtype", json!({"value": false}));
+                }
                 if let Some((msg, at)) = &app.status_msg
                     && crate::now_ms() - at < 6000.0
                 {
diff --git a/crates/ui-egui/src/colors.rs b/crates/ui-egui/src/colors.rs
new file mode 100644
index 0000000000..e82bd920c3
--- /dev/null
+++ b/crates/ui-egui/src/colors.rs
@@ -0,0 +1,847 @@
+//! Colour menus and the Colors dialog (More Colors…, #606).
+//!
+//! Every colour drop-down (Font Color, Shading, Page Color, Shape Fill/Outline, pen colours, and
+//! the colour fields inside dialogs) shows the theme and standard colours, a Recent Colors row and
+//! a More Colors… item. More Colors… opens the Colors dialog: a Standard tab (a honeycomb of
+//! colours and a row of greys) and a Custom tab (a hue × saturation field with a lightness
+//! slider, RGB or HSL numbers and a hex box). Everything is drawn in code.
+//!
+//! What a pick does is a [`Target`]: run a command with the colour put into its params, or hand
+//! the colour back to a dialog's field. The colour a command takes is any `RRGGBB`, so a custom
+//! colour needs nothing new below the UI.
+
+use egui::{Color32, Id, Pos2, Rect, Sense, Stroke, Ui, pos2, vec2};
+use serde_json::{Value, json};
+use wordcraft_doc::Rgb;
+
+use crate::WordApp;
+use crate::theme::{Tokens, c32};
+
+/// How many colours Recent Colors keeps.
+pub const RECENT_MAX: usize = 10;
+
+// ---------------------------------------------------------------------------------------------
+// Pure helpers
+
+/// A colour typed by a person: `RRGGBB`, `#RRGGBB`, `#RGB`, `0xRRGGBB`, `rgb(r, g, b)` or three
+/// numbers 0–255 separated by commas or spaces. Anything else is `None`.
+pub fn parse(s: &str) -> Option<Rgb> {
+    let s = s.trim();
+    let hex = s.trim_start_matches('#');
+    let hex = hex.strip_prefix("0x").or_else(|| hex.strip_prefix("0X")).unwrap_or(hex);
+    if hex.len() == 6 {
+        if let Some(c) = Rgb::parse(hex) {
+            return Some(c);
+        }
+    } else if hex.len() == 3 && hex.is_ascii() {
+        let d = |i: usize| hex.get(i..i + 1).and_then(|h| u8::from_str_radix(h, 16).ok()).map(|v| v * 17);
+        if let (Some(r), Some(g), Some(b)) = (d(0), d(1), d(2)) {
+            return Some(Rgb(r, g, b));
+        }
+    }
+    let lower = s.to_ascii_lowercase();
+    let inner = lower.strip_prefix("rgb").map(|r| r.trim().trim_start_matches('(').trim_end_matches(')')).unwrap_or(&lower);
+    let parts: Vec<&str> = inner.split(|c: char| c == ',' || c.is_whitespace()).filter(|p| !p.is_empty()).collect();
+    if parts.len() != 3 {
+        return None;
+    }
+    let n = |i: usize| parts.get(i).and_then(|p| p.parse::<u8>().ok());
+    Some(Rgb(n(0)?, n(1)?, n(2)?))
+}
+
+/// Hue (degrees, 0–360), saturation and lightness (0–1) of a colour.
+pub fn to_hsl(c: Rgb) -> (f32, f32, f32) {
+    let (r, g, b) = (c.0 as f32 / 255.0, c.1 as f32 / 255.0, c.2 as f32 / 255.0);
+    let max = r.max(g).max(b);
+    let min = r.min(g).min(b);
+    let l = (max + min) / 2.0;
+    let d = max - min;
+    if d <= f32::EPSILON {
+        return (0.0, 0.0, l);
+    }
+    let s = if l > 0.5 { d / (2.0 - max - min) } else { d / (max + min) };
+    let h = if max == r {
+        (g - b) / d + if g < b { 6.0 } else { 0.0 }
+    } else if max == g {
+        (b - r) / d + 2.0
+    } else {
+        (r - g) / d + 4.0
+    };
+    ((h * 60.0).rem_euclid(360.0), s.clamp(0.0, 1.0), l.clamp(0.0, 1.0))
+}
+
+/// The colour with hue `h` (degrees, any value wraps), saturation `s` and lightness `l` (0–1,
+/// clamped). Non-finite input counts as 0.
+pub fn from_hsl(h: f32, s: f32, l: f32) -> Rgb {
+    let fin = |v: f32| if v.is_finite() { v } else { 0.0 };
+    let h = fin(h).rem_euclid(360.0);
+    let s = fin(s).clamp(0.0, 1.0);
+    let l = fin(l).clamp(0.0, 1.0);
+    let c = (1.0 - (2.0 * l - 1.0).abs()) * s;
+    let hp = h / 60.0;
+    let x = c * (1.0 - (hp.rem_euclid(2.0) - 1.0).abs());
+    let (r, g, b) = match hp as u32 {
+        0 => (c, x, 0.0),
+        1 => (x, c, 0.0),
+        2 => (0.0, c, x),
+        3 => (0.0, x, c),
+        4 => (x, 0.0, c),
+        _ => (c, 0.0, x),
+    };
+    let m = l - c / 2.0;
+    let q = |v: f32| ((v + m) * 255.0).round().clamp(0.0, 255.0) as u8;
+    Rgb(q(r), q(g), q(b))
+}
+
+/// Puts `hex` first in a Recent Colors list (no repeats, at most [`RECENT_MAX`]). Junk is ignored.
+pub fn push_recent(list: &mut Vec<String>, hex: &str) {
+    let Some(c) = parse(hex) else { return };
+    let hex = c.hex();
+    list.retain(|h| parse(h).map(Rgb::hex).as_deref() != Some(hex.as_str()));
+    list.insert(0, hex);
+    list.truncate(RECENT_MAX);
+}
+
+/// The Recent Colors to show from a saved list: valid colours only, no repeats, at most
+/// [`RECENT_MAX`].
+pub fn recent(list: &[String]) -> Vec<Rgb> {
+    let mut out: Vec<Rgb> = Vec::new();
+    for c in list.iter().filter_map(|h| parse(h)) {
+        if !out.contains(&c) {
+            out.push(c);
+        }
+        if out.len() >= RECENT_MAX {
+            break;
+        }
+    }
+    out
+}
+
+/// Rings of the Standard tab's honeycomb around its white centre.
+pub const HONEYCOMB_RINGS: i32 = 6;
+
+/// The Standard tab's honeycomb: axial cell coordinates `(q, r)` and their colours. The centre is
+/// white; going out, colours get more saturated and then darker; the hue follows the angle.
+pub fn honeycomb() -> Vec<(i32, i32, Rgb)> {
+    let n = HONEYCOMB_RINGS;
+    let mut cells = Vec::new();
+    for r in -n..=n {
+        for q in -n..=n {
+            let d = q.abs().max(r.abs()).max((q + r).abs());
+            if d > n {
+                continue;
+            }
+            let (x, y) = cell_xy(q, r);
+            let hue = (-y).atan2(x).to_degrees();
+            let t = d as f32 / n as f32;
+            cells.push((q, r, from_hsl(hue, 1.0, 1.0 - 0.75 * t)));
+        }
+    }
+    cells
+}
+
+/// The greys under the honeycomb, white to black.
+pub fn greys() -> Vec<Rgb> {
+    (0..=14u32)
+        .map(|i| {
+            let v = (255 - (i * 255 / 14).min(255)) as u8;
+            Rgb(v, v, v)
+        })
+        .collect()
+}
+
+/// A cell's centre in units of the cell radius (pointy-top hexagons).
+fn cell_xy(q: i32, r: i32) -> (f32, f32) {
+    (3f32.sqrt() * (q as f32 + r as f32 / 2.0), 1.5 * r as f32)
+}
+
+// ---------------------------------------------------------------------------------------------
+// Targets
+
+/// What a menu remembers as the split button's colour.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Remember {
+    Nothing,
+    FontColor,
+    Shading,
+}
+
+/// Where a picked colour goes.
+#[derive(Clone, Debug, PartialEq)]
+pub enum Target {
+    /// Run `cmd` with the colour (`RRGGBB`) put into `params` at the JSON pointer `at`.
+    Run { cmd: String, params: Value, at: String, remember: Remember },
+    /// A dialog's colour field (see [`field_menu`]).
+    Field(Id),
+}
+
+impl Target {
+    /// `cmd` with params `{"color": RRGGBB}`.
+    pub fn cmd(cmd: &str) -> Target {
+        Target::Run { cmd: cmd.into(), params: json!({"color": null}), at: "/color".into(), remember: Remember::Nothing }
+    }
+
+    /// `cmd` with the colour at the JSON pointer `at` inside `params`.
+    pub fn at(cmd: &str, params: Value, at: &str) -> Target {
+        Target::Run { cmd: cmd.into(), params, at: at.into(), remember: Remember::Nothing }
+    }
+
+    pub fn remember(self, r: Remember) -> Target {
+        match self {
+            Target::Run { cmd, params, at, .. } => Target::Run { cmd, params, at, remember: r },
+            t => t,
+        }
+    }
+
+    /// The command and params a pick of `hex` runs (`None` for a field).
+    pub fn command(&self, hex: &str) -> Option<(String, Value)> {
+        let Target::Run { cmd, params, at, .. } = self else { return None };
+        let mut p = params.clone();
+        match p.pointer_mut(at) {
+            Some(slot) => *slot = json!(hex),
+            None => p["color"] = json!(hex),
+        }
+        Some((cmd.clone(), p))
+    }
+}
+
+/// Apply a picked colour to its target.
+pub fn apply(app: &mut WordApp, ctx: &egui::Context, target: &Target, hex: &str) {
+    match target {
+        Target::Run { remember, .. } => {
+            match remember {
+                Remember::FontColor => app.canvas.last_font_color = hex.to_string(),
+                Remember::Shading => app.canvas.last_shading = hex.to_string(),
+                Remember::Nothing => {}
+            }
+            if let Some((cmd, p)) = target.command(hex) {
+                let _ = app.run(&cmd, p);
+            }
+        }
+        Target::Field(id) => {
+            ctx.data_mut(|d| d.insert_temp(*id, FieldResult(hex.to_string())));
+            ctx.request_repaint();
+        }
+    }
+}
+
+/// The colour a target has now (the dialog's Current swatch).
+fn current_of(app: &mut WordApp, target: &Target) -> Option<Rgb> {
+    let Target::Run { cmd, .. } = target else { return None };
+    match cmd.as_str() {
+        "format.color" => {
+            let st = app.session.run("format.state", &json!({})).ok()?;
+            st.get("color").and_then(Value::as_str).and_then(parse)
+        }
+        _ => None,
+    }
+}
+
+// ---------------------------------------------------------------------------------------------
+// The drop-down
+
+/// A choice in a colour drop-down.
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Pick {
+    Color(String),
+    More,
+}
+
+fn recent_id() -> Id {
+    Id::new("wordcraft.recentColors")
+}
+
+fn request_id() -> Id {
+    Id::new("wordcraft.moreColorsRequest")
+}
+
+fn open_flag_id() -> Id {
+    Id::new("wordcraft.colorsDialogOpen")
+}
+
+/// Removes and returns a temporary value.
+fn take<T: Clone + Send + Sync + 'static>(d: &mut egui::util::IdTypeMap, id: Id) -> Option<T> {
+    let v = d.get_temp::<T>(id);
+    d.remove::<T>(id);
+    v
+}
+
+#[derive(Clone)]
+struct FieldRequest(Id, Option<Rgb>);
+
+#[derive(Clone)]
+struct FieldResult(String);
+
+/// The drop-down's body: theme and standard colours, Recent Colors, More Colors….
+pub fn palette(ui: &mut Ui, theme: &[Rgb]) -> Option<Pick> {
+    let mut picked = crate::widgets::color_grid(ui, theme).map(Pick::Color);
+    let recent: Vec<String> = ui.data(|d| d.get_temp::<Vec<String>>(recent_id())).unwrap_or_default();
+    let recent = self::recent(&recent);
+    if !recent.is_empty() {
+        ui.add_space(4.0);
+        ui.label(egui::RichText::new(tl!("Recent Colors")).small().weak());
+        ui.horizontal(|ui| {
+            ui.spacing_mut().item_spacing = vec2(3.0, 0.0);
+            for c in recent {
+                if crate::widgets::swatch(ui, c) {
+                    picked = Some(Pick::Color(c.hex()));
+                }
+            }
+        });
+    }
+    ui.add_space(2.0);
+    ui.separator();
+    if more_item(ui).clicked() {
+        picked = Some(Pick::More);
+    }
+    picked
+}
+
+/// The More Colors… row: a small rainbow wheel and the label.
+fn more_item(ui: &mut Ui) -> egui::Response {
+    let t = Tokens::get(ui.ctx());
+    let (r, resp) = ui.allocate_exact_size(vec2(180.0, 22.0), Sense::click());
+    if resp.hovered() {
+        ui.painter().rect_filled(r, 2.0, t.hover);
+    }
+    let c = pos2(r.min.x + 10.0, r.center().y);
+    for i in 0..12 {
+        let a0 = (i as f32) * std::f32::consts::TAU / 12.0;
+        let a1 = a0 + std::f32::consts::TAU / 12.0;
+        let p = |a: f32| c + vec2(a.cos(), a.sin()) * 6.5;
+        let col = c32(from_hsl(i as f32 * 30.0, 1.0, 0.5));
+        ui.painter().add(egui::Shape::convex_polygon(vec![c, p(a0), p(a1)], col, Stroke::NONE));
+    }
+    ui.painter().circle_stroke(c, 6.5, Stroke::new(0.5, t.border_strong));
+    ui.painter().text(
+        pos2(r.min.x + 22.0, r.center().y),
+        egui::Align2::LEFT_CENTER,
+        tl!("More Colors…"),
+        egui::TextStyle::Button.resolve(ui.style()),
+        t.text,
+    );
+    resp
+}
+
+/// A command colour drop-down's body: picks run `target`, More Colors… opens the Colors dialog.
+pub fn menu(ui: &mut Ui, app: &mut WordApp, theme: &[Rgb], target: Target) {
+    match palette(ui, theme) {
+        Some(Pick::Color(hex)) => {
+            let ctx = ui.ctx().clone();
+            apply(app, &ctx, &target, &hex);
+            ui.close();
+        }
+        Some(Pick::More) => {
+            let current = current_of(app, &target);
+            app.colors = Some(ColorsDialog::new(current, target));
+            ui.close();
+        }
+        None => {}
+    }
+}
+
+/// A dialog field's drop-down body (the dialog has no access to the app): a pick sets `value`;
+/// More Colors… asks for the Colors dialog, whose answer [`take_field`] collects. `id` must be
+/// the same each frame.
+pub fn field_menu(ui: &mut Ui, theme: &[Rgb], id: Id, value: &mut String) {
+    match palette(ui, theme) {
+        Some(Pick::Color(hex)) => {
+            *value = hex;
+            ui.close();
+        }
+        Some(Pick::More) => {
+            let current = parse(value);
+            ui.data_mut(|d| d.insert_temp(request_id(), FieldRequest(id, current)));
+            ui.close();
+        }
+        None => {}
+    }
+}
+
+/// The Colors dialog's answer for the field `id`, if it just closed with OK.
+pub fn take_field(ctx: &egui::Context, id: Id, value: &mut String) {
+    if let Some(FieldResult(hex)) = ctx.data_mut(|d| take::<FieldResult>(d, id)) {
+        *value = hex;
+    }
+}
+
+/// Whether the Colors dialog was open last frame: dialogs under it leave Enter and Escape to it.
+pub fn is_open(ctx: &egui::Context) -> bool {
+    ctx.data(|d| d.get_temp::<bool>(open_flag_id())).unwrap_or(false)
+}
+
+// ---------------------------------------------------------------------------------------------
+// The Colors dialog
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum ColorsTab {
+    Standard,
+    Custom,
+}
+
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum Model {
+    Rgb,
+    Hsl,
+}
+
+/// The Colors dialog's state.
+#[derive(Clone, Debug)]
+pub struct ColorsDialog {
+    pub tab: ColorsTab,
+    /// The new colour.
+    pub color: Rgb,
+    /// Hue, saturation, lightness of `color`; the hue is kept through greys so dragging the
+    /// lightness back out of black or white returns to it.
+    pub hsl: (f32, f32, f32),
+    /// The colour the target had when the dialog opened.
+    pub current: Option<Rgb>,
+    pub model: Model,
+    /// The hex box's text (may be mid-edit).
+    pub hex: String,
+    pub target: Target,
+}
+
+impl ColorsDialog {
+    pub fn new(current: Option<Rgb>, target: Target) -> ColorsDialog {
+        let c = current.unwrap_or(Rgb::BLACK);
+        let mut d = ColorsDialog { tab: ColorsTab::Standard, color: c, hsl: (0.0, 0.0, 0.0), current, model: Model::Rgb, hex: String::new(), target };
+        d.set_rgb(c);
+        d
+    }
+
+    pub fn set_rgb(&mut self, c: Rgb) {
+        let (h, s, l) = to_hsl(c);
+        let h = if s > 0.0 && l > 0.0 && l < 1.0 { h } else { self.hsl.0 };
+        self.color = c;
+        self.hsl = (h, s, l);
+        self.hex = c.hex();
+    }
+
+    pub fn set_hsl(&mut self, h: f32, s: f32, l: f32) {
+        self.hsl = (h.rem_euclid(360.0), s.clamp(0.0, 1.0), l.clamp(0.0, 1.0));
+        self.color = from_hsl(self.hsl.0, self.hsl.1, self.hsl.2);
+        self.hex = self.color.hex();
+    }
+
+    /// Sets the colour from typed text; returns whether it was a colour.
+    pub fn set_text(&mut self, s: &str) -> bool {
+        match parse(s) {
+            Some(c) => {
+                let (h, sat, l) = to_hsl(c);
+                let h = if sat > 0.0 { h } else { self.hsl.0 };
+                self.color = c;
+                self.hsl = (h, sat, l);
+                true
+            }
+            None => false,
+        }
+    }
+}
+
+/// Draws the Colors dialog if it is open (and opens it for a dialog field that asked).
+pub fn show(app: &mut WordApp, ctx: &egui::Context) {
+    ctx.data_mut(|d| d.insert_temp(recent_id(), app.ui.recent_colors.clone()));
+    if let Some(FieldRequest(id, current)) = ctx.data_mut(|d| take::<FieldRequest>(d, request_id())) {
+        app.colors = Some(ColorsDialog::new(current, Target::Field(id)));
+    }
+    let Some(mut d) = app.colors.take() else {
+        ctx.data_mut(|m| m.insert_temp(open_flag_id(), false));
+        return;
+    };
+    let resp = egui::Modal::new(Id::new("wordcraft.colorsDialog")).show(ctx, |ui| body(ui, &mut d));
+    let mut done = resp.inner;
+    if done.is_none() && resp.should_close() {
+        done = Some(false);
+    }
+    match done {
+        Some(ok) => {
+            ctx.data_mut(|m| m.insert_temp(open_flag_id(), false));
+            if ok {
+                finish(app, ctx, &d);
+            }
+            if matches!(d.target, Target::Run { .. }) && app.dialog.is_none() {
+                app.canvas.want_focus = true;
+            }
+        }
+        None => {
+            ctx.data_mut(|m| m.insert_temp(open_flag_id(), true));
+            app.colors = Some(d);
+        }
+    }
+}
+
+/// OK: the colour joins Recent Colors and goes to the target.
+pub fn finish(app: &mut WordApp, ctx: &egui::Context, d: &ColorsDialog) {
+    let hex = d.color.hex();
+    push_recent(&mut app.ui.recent_colors, &hex);
+    ctx.data_mut(|m| m.insert_temp(recent_id(), app.ui.recent_colors.clone()));
+    apply(app, ctx, &d.target, &hex);
+}
+
+/// The dialog's contents. `Some(true)` for OK, `Some(false)` for Cancel.
+fn body(ui: &mut Ui, d: &mut ColorsDialog) -> Option<bool> {
+    let t = Tokens::get(ui.ctx());
+    ui.set_width(430.0);
+    ui.label(egui::RichText::new(tl!("Colors")).font(crate::theme::semibold(14.0)));
+    ui.add_space(6.0);
+    ui.horizontal(|ui| {
+        for (tab, label) in [(ColorsTab::Standard, "Standard"), (ColorsTab::Custom, "Custom")] {
+            if ui.selectable_label(d.tab == tab, tl!(label)).clicked() {
+                d.tab = tab;
+            }
+        }
+    });
+    ui.separator();
+    ui.horizontal(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(330.0);
+            match d.tab {
+                ColorsTab::Standard => standard(ui, d),
+                ColorsTab::Custom => custom(ui, d),
+            }
+        });
+        ui.vertical(|ui| {
+            ui.add_space(110.0);
+            preview(ui, d, &t);
+        });
+    });
+    let mut out = None;
+    ui.add_space(8.0);
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if ui.button(tl!("Cancel")).clicked() {
+                out = Some(false);
+            }
+            let okb = ui.add(egui::Button::new(egui::RichText::new(tl!("OK")).color(Color32::WHITE)).fill(crate::theme::APP_COLOR));
+            let typing = ui.ctx().memory(|m| m.focused().is_some());
+            if okb.clicked() || (!typing && ui.input(|i| i.key_pressed(egui::Key::Enter))) {
+                out = Some(true);
+            }
+        });
+    });
+    out
+}
+
+/// New over Current, as two halves of one swatch.
+fn preview(ui: &mut Ui, d: &ColorsDialog, t: &Tokens) {
+    ui.label(egui::RichText::new(tl!("New")).small());
+    let (r, _) = ui.allocate_exact_size(vec2(64.0, 72.0), Sense::hover());
+    let top = Rect::from_min_max(r.min, pos2(r.max.x, r.center().y));
+    let bottom = Rect::from_min_max(pos2(r.min.x, r.center().y), r.max);
+    ui.painter().rect_filled(top, 0.0, c32(d.color));
+    match d.current {
+        Some(c) => {
+            ui.painter().rect_filled(bottom, 0.0, c32(c));
+        }
+        None => {
+            ui.painter().rect_filled(bottom, 0.0, t.panel);
+            ui.painter().line_segment([bottom.left_bottom(), bottom.right_top()], Stroke::new(1.0, t.text_dim));
+        }
+    }
+    ui.painter().rect_stroke(r, 0.0, Stroke::new(1.0, t.border_strong), egui::StrokeKind::Inside);
+    ui.label(egui::RichText::new(tl!("Current")).small());
+}
+
+/// Pointy-top hexagon corners around `c` with radius `s`.
+fn hexagon(c: Pos2, s: f32) -> Vec<Pos2> {
+    (0..6)
+        .map(|i| {
+            let a = (60.0 * i as f32 - 30.0).to_radians();
+            c + vec2(a.cos(), a.sin()) * s
+        })
+        .collect()
+}
+
+fn standard(ui: &mut Ui, d: &mut ColorsDialog) {
+    let t = Tokens::get(ui.ctx());
+    ui.label(tl!("Colors:"));
+    let s = 11.0;
+    let n = HONEYCOMB_RINGS as f32;
+    let size = vec2(3f32.sqrt() * s * (2.0 * n + 1.0) + 2.0, s * (3.0 * n + 2.0) + 2.0);
+    let (rect, resp) = ui.allocate_exact_size(vec2(ui.available_width(), size.y), Sense::click());
+    let centre = rect.center();
+    let cells = honeycomb();
+    let at = |q: i32, r: i32| {
+        let (x, y) = cell_xy(q, r);
+        centre + vec2(x, y) * s
+    };
+    let hit = |p: Pos2, centres: Vec<(Pos2, Rgb)>| centres.into_iter().find(|(c, _)| c.distance(p) < s * 0.9).map(|(_, col)| col);
+    let mut selected = None;
+    for &(q, r, col) in &cells {
+        let c = at(q, r);
+        ui.painter().add(egui::Shape::convex_polygon(hexagon(c, s), c32(col), Stroke::new(0.5, t.border_strong)));
+        if col == d.color {
+            selected = Some(c);
+        }
+    }
+    if let Some(p) = resp.interact_pointer_pos().filter(|_| resp.clicked())
+        && let Some(col) = hit(p, cells.iter().map(|&(q, r, col)| (at(q, r), col)).collect())
+    {
+        d.set_rgb(col);
+    }
+    // Greys: one row of hexagons under the honeycomb.
+    ui.add_space(6.0);
+    let greys = greys();
+    let w = 3f32.sqrt() * s;
+    let (row, gresp) = ui.allocate_exact_size(vec2(ui.available_width(), s * 2.0 + 2.0), Sense::click());
+    let x0 = row.center().x - w * (greys.len() as f32 - 1.0) / 2.0;
+    let gat = |i: usize| pos2(x0 + w * i as f32, row.center().y);
+    for (i, col) in greys.iter().enumerate() {
+        let c = gat(i);
+        ui.painter().add(egui::Shape::convex_polygon(hexagon(c, s), c32(*col), Stroke::new(0.5, t.border_strong)));
+        if *col == d.color {
+            selected = Some(c);
+        }
+    }
+    if let Some(p) = gresp.interact_pointer_pos().filter(|_| gresp.clicked())
+        && let Some(col) = hit(p, greys.iter().enumerate().map(|(i, col)| (gat(i), *col)).collect())
+    {
+        d.set_rgb(col);
+    }
+    if let Some(c) = selected {
+        ui.painter().add(egui::Shape::closed_line(hexagon(c, s), Stroke::new(2.5, Color32::WHITE)));
+        ui.painter().add(egui::Shape::closed_line(hexagon(c, s + 1.5), Stroke::new(1.0, Color32::BLACK)));
+    }
+}
+
+fn custom(ui: &mut Ui, d: &mut ColorsDialog) {
+    let t = Tokens::get(ui.ctx());
+    ui.label(tl!("Colors:"));
+    ui.horizontal(|ui| {
+        // Hue across, saturation up; drawn at the middle lightness.
+        let (field, fresp) = ui.allocate_exact_size(vec2(280.0, 170.0), Sense::click_and_drag());
+        let mut mesh = egui::Mesh::default();
+        let (cols, rows) = (36u32, 6u32);
+        for j in 0..=rows {
+            for i in 0..=cols {
+                let (u, v) = (i as f32 / cols as f32, j as f32 / rows as f32);
+                let p = pos2(field.min.x + u * field.width(), field.min.y + v * field.height());
+                mesh.colored_vertex(p, c32(from_hsl(u * 360.0, 1.0 - v, 0.5)));
+            }
+        }
+        for j in 0..rows {
+            for i in 0..cols {
+                let a = j * (cols + 1) + i;
+                mesh.add_triangle(a, a + 1, a + cols + 1);
+                mesh.add_triangle(a + 1, a + cols + 2, a + cols + 1);
+            }
+        }
+        ui.painter().add(egui::Shape::mesh(mesh));
+        ui.painter().rect_stroke(field, 0.0, Stroke::new(1.0, t.border_strong), egui::StrokeKind::Outside);
+        if let Some(p) = fresp.interact_pointer_pos().filter(|_| fresp.clicked() || fresp.dragged()) {
+            let u = ((p.x - field.min.x) / field.width()).clamp(0.0, 1.0);
+            let v = ((p.y - field.min.y) / field.height()).clamp(0.0, 1.0);
+            let l = if d.hsl.2 <= 0.0 || d.hsl.2 >= 1.0 { 0.5 } else { d.hsl.2 };
+            d.set_hsl(u * 359.9, 1.0 - v, l);
+        }
+        let m = pos2(field.min.x + d.hsl.0 / 360.0 * field.width(), field.min.y + (1.0 - d.hsl.1) * field.height());
+        ui.painter().circle_stroke(m, 5.0, Stroke::new(2.0, Color32::BLACK));
+        ui.painter().circle_stroke(m, 4.0, Stroke::new(1.0, Color32::WHITE));
+
+        // Lightness: white at the top, black at the bottom, through the picked hue and saturation.
+        let (bar, bresp) = ui.allocate_exact_size(vec2(16.0, 170.0), Sense::click_and_drag());
+        let mut mesh = egui::Mesh::default();
+        let steps = 16u32;
+        for k in 0..=steps {
+            let v = k as f32 / steps as f32;
+            let col = c32(from_hsl(d.hsl.0, d.hsl.1, 1.0 - v));
+            let y = bar.min.y + v * bar.height();
+            mesh.colored_vertex(pos2(bar.min.x, y), col);
+            mesh.colored_vertex(pos2(bar.max.x, y), col);
+        }
+        for k in 0..steps {
+            let a = k * 2;
+            mesh.add_triangle(a, a + 1, a + 2);
+            mesh.add_triangle(a + 1, a + 3, a + 2);
+        }
+        ui.painter().add(egui::Shape::mesh(mesh));
+        ui.painter().rect_stroke(bar, 0.0, Stroke::new(1.0, t.border_strong), egui::StrokeKind::Outside);
+        if let Some(p) = bresp.interact_pointer_pos().filter(|_| bresp.clicked() || bresp.dragged()) {
+            let v = ((p.y - bar.min.y) / bar.height()).clamp(0.0, 1.0);
+            d.set_hsl(d.hsl.0, d.hsl.1, 1.0 - v);
+        }
+        let y = bar.min.y + (1.0 - d.hsl.2) * bar.height();
+        let tip = pos2(bar.max.x + 2.0, y);
+        ui.painter().add(egui::Shape::convex_polygon(vec![tip, tip + vec2(7.0, -5.0), tip + vec2(7.0, 5.0)], t.text, Stroke::NONE));
+        ui.add_space(8.0);
+    });
+    ui.add_space(8.0);
+    egui::Grid::new("colors_custom").num_columns(2).spacing(vec2(10.0, 5.0)).show(ui, |ui| {
+        ui.label(tl!("Color model:"));
+        egui::ComboBox::from_id_salt("colors_model")
+            .selected_text(match d.model {
+                Model::Rgb => "RGB",
+                Model::Hsl => "HSL",
+            })
+            .width(90.0)
+            .show_ui(ui, |ui| {
+                ui.selectable_value(&mut d.model, Model::Rgb, "RGB");
+                ui.selectable_value(&mut d.model, Model::Hsl, "HSL");
+            });
+        ui.end_row();
+        match d.model {
+            Model::Rgb => {
+                let mut c = [d.color.0, d.color.1, d.color.2];
+                let mut changed = false;
+                for (i, label) in ["Red:", "Green:", "Blue:"].into_iter().enumerate() {
+                    ui.label(tl!(label));
+                    if let Some(v) = c.get_mut(i) {
+                        changed |= ui.add(egui::DragValue::new(v).range(0..=255).speed(1.0)).changed();
+                    }
+                    ui.end_row();
+                }
+                if changed {
+                    d.set_rgb(Rgb(c[0], c[1], c[2]));
+                }
+            }
+            Model::Hsl => {
+                // Word-style 0–255 scales for all three.
+                let to255 = |v: f32| (v * 255.0).round().clamp(0.0, 255.0) as u8;
+                let mut v = [to255(d.hsl.0 / 360.0), to255(d.hsl.1), to255(d.hsl.2)];
+                let mut changed = false;
+                for (i, label) in ["Hue:", "Sat:", "Lum:"].into_iter().enumerate() {
+                    ui.label(tl!(label));
+                    if let Some(x) = v.get_mut(i) {
+                        changed |= ui.add(egui::DragValue::new(x).range(0..=255).speed(1.0)).changed();
+                    }
+                    ui.end_row();
+                }
+                if changed {
+                    d.set_hsl(v[0] as f32 / 255.0 * 360.0, v[1] as f32 / 255.0, v[2] as f32 / 255.0);
+                }
+            }
+        }
+        ui.label(tl!("Hex:"));
+        ui.horizontal(|ui| {
+            ui.label("#");
+            let mut text = d.hex.clone();
+            let r = ui.add(egui::TextEdit::singleline(&mut text).desired_width(80.0).char_limit(16));
+            if r.changed() {
+                d.hex = text.clone();
+                d.set_text(&text);
+            }
+            if r.lost_focus() {
+                d.hex = d.color.hex();
+            }
+        });
+        ui.end_row();
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use wordcraft_engine::Session;
+
+    #[test]
+    fn parse_accepts_hex_short_hex_and_rgb_triples() {
+        assert_eq!(parse("1A2B3C"), Some(Rgb(0x1A, 0x2B, 0x3C)));
+        assert_eq!(parse("  #1a2b3c "), Some(Rgb(0x1A, 0x2B, 0x3C)));
+        assert_eq!(parse("0xFF8800"), Some(Rgb(0xFF, 0x88, 0x00)));
+        assert_eq!(parse("#f80"), Some(Rgb(0xFF, 0x88, 0x00)));
+        assert_eq!(parse("rgb(12, 34, 56)"), Some(Rgb(12, 34, 56)));
+        assert_eq!(parse("12 34 56"), Some(Rgb(12, 34, 56)));
+        for junk in ["", "#", "#12345", "GGGGGG", "rgb(1,2)", "256,0,0", "-1,0,0", "ééé", "#ééé", "1,2,3,4", "\u{0}"] {
+            assert_eq!(parse(junk), None, "{junk:?}");
+        }
+    }
+
+    #[test]
+    fn hsl_round_trips_every_colour_channel_step() {
+        for r in (0..=255u8).step_by(15) {
+            for g in (0..=255u8).step_by(17) {
+                for b in (0..=255u8).step_by(51) {
+                    let c = Rgb(r, g, b);
+                    let (h, s, l) = to_hsl(c);
+                    assert!((0.0..360.0).contains(&h) && (0.0..=1.0).contains(&s) && (0.0..=1.0).contains(&l));
+                    assert_eq!(from_hsl(h, s, l), c);
+                }
+            }
+        }
+        assert_eq!(from_hsl(0.0, 1.0, 0.5), Rgb(255, 0, 0));
+        assert_eq!(from_hsl(120.0, 1.0, 0.5), Rgb(0, 255, 0));
+        assert_eq!(from_hsl(240.0, 1.0, 0.5), Rgb(0, 0, 255));
+        assert_eq!(from_hsl(-120.0, 1.0, 0.5), Rgb(0, 0, 255), "hue wraps");
+        assert_eq!(from_hsl(f32::NAN, f32::INFINITY, -3.0), Rgb(0, 0, 0), "junk input is clamped, never a panic");
+    }
+
+    #[test]
+    fn recent_colors_dedupe_and_cap() {
+        let mut list = vec!["junk".to_string()];
+        for i in 0..15u8 {
+            push_recent(&mut list, &Rgb(i, i, i).hex());
+        }
+        push_recent(&mut list, "#0e0e0e");
+        push_recent(&mut list, "not a colour");
+        assert_eq!(list.len(), RECENT_MAX);
+        assert_eq!(list.first().map(String::as_str), Some("0E0E0E"));
+        assert_eq!(list.iter().filter(|h| *h == "0E0E0E").count(), 1);
+        let saved = vec!["FF0000".to_string(), "ff0000".into(), "nope".into(), "00FF00".into()];
+        assert_eq!(recent(&saved), vec![Rgb(255, 0, 0), Rgb(0, 255, 0)]);
+    }
+
+    #[test]
+    fn honeycomb_is_white_in_the_middle_and_has_every_hue() {
+        let cells = honeycomb();
+        assert_eq!(cells.len(), 127, "6 rings around the centre");
+        assert_eq!(cells.iter().find(|(q, r, _)| (*q, *r) == (0, 0)).map(|c| c.2), Some(Rgb::WHITE));
+        let mid: Vec<Rgb> = cells.iter().filter(|(q, r, _)| q.abs().max(r.abs()).max((q + r).abs()) == 3).map(|c| c.2).collect();
+        assert!(mid.iter().any(|c| c.0 > 200 && c.1 < 100 && c.2 < 100), "a red");
+        assert!(mid.iter().any(|c| c.1 > 200 && c.0 < 100 && c.2 < 100), "a green");
+        assert!(mid.iter().any(|c| c.2 > 200 && c.0 < 100 && c.1 < 100), "a blue");
+        let g = greys();
+        assert_eq!((g.first().copied(), g.last().copied()), (Some(Rgb::WHITE), Some(Rgb::BLACK)));
+    }
+
+    #[test]
+    fn targets_put_the_colour_where_the_command_wants_it() {
+        assert_eq!(Target::cmd("format.color").command("1A2B3C"), Some(("format.color".into(), json!({"color": "1A2B3C"}))));
+        let glow = Target::at("shape.effects", json!({"glow": {"color": null, "size": 8.0}}), "/glow/color");
+        assert_eq!(glow.command("00FF00"), Some(("shape.effects".into(), json!({"glow": {"color": "00FF00", "size": 8.0}}))));
+        assert_eq!(Target::Field(Id::new("x")).command("00FF00"), None);
+    }
+
+    #[test]
+    fn dialog_keeps_hue_through_grey_and_reads_typed_colours() {
+        let mut d = ColorsDialog::new(Some(Rgb(255, 0, 0)), Target::cmd("format.color"));
+        d.set_hsl(200.0, 0.0, 0.5);
+        assert_eq!(d.hsl.0, 200.0, "grey keeps the hue");
+        d.set_hsl(d.hsl.0, 1.0, 0.5);
+        assert_eq!(d.color, from_hsl(200.0, 1.0, 0.5));
+        assert!(d.set_text("#123456"));
+        assert_eq!(d.color, Rgb(0x12, 0x34, 0x56));
+        assert!(!d.set_text("#12"), "an unfinished hex keeps the colour");
+        assert_eq!(d.color, Rgb(0x12, 0x34, 0x56));
+    }
+
+    /// #606: More Colors… for the font colour opens the Colors dialog with the selection's colour
+    /// as Current; OK applies the custom colour, remembers it on the split button and puts it
+    /// first in Recent Colors.
+    #[test]
+    fn custom_font_color_applies_and_joins_recent_colors() {
+        let mut app = WordApp::new(Session::new(wordcraft_doc::Document::new()), crate::Services::default());
+        let _ = app.run("document.setText", json!({"text": "Custom colour"}));
+        let _ = app.run("select.all", json!({}));
+        let _ = app.run("format.color", json!({"color": "112233"}));
+        let r = app.run("ui.dialog", json!({"name": "colors"}));
+        assert_eq!(r.ok().and_then(|v| v.get("dialog").cloned()), Some(json!("colors")));
+        assert!(!crate::mini_toolbar::visible(&app), "the mini toolbar stays out of the Colors dialog's way");
+        let mut d = app.colors.take().unwrap_or_else(|| panic!("the Colors dialog opens"));
+        assert_eq!(d.current, Some(Rgb(0x11, 0x22, 0x33)));
+        assert!(d.set_text("#7A3EC8"));
+        let ctx = egui::Context::default();
+        finish(&mut app, &ctx, &d);
+        let st = app.session.run("format.state", &json!({})).unwrap_or_default();
+        assert_eq!(st.get("color"), Some(&json!("7A3EC8")));
+        assert_eq!(app.canvas.last_font_color, "7A3EC8");
+        assert_eq!(app.ui.recent_colors.first().map(String::as_str), Some("7A3EC8"));
+        // A dialog field gets the colour back instead.
+        let id = Id::new("field");
+        d.target = Target::Field(id);
+        finish(&mut app, &ctx, &d);
+        let mut value = String::new();
+        take_field(&ctx, id, &mut value);
+        assert_eq!(value, "7A3EC8");
+    }
+}
diff --git a/crates/ui-egui/src/content_controls.rs b/crates/ui-egui/src/content_controls.rs
new file mode 100644
index 0000000000..2febf59634
--- /dev/null
+++ b/crates/ui-egui/src/content_controls.rs
@@ -0,0 +1,243 @@
+//! Content controls on the page: the frame and title tab of the control the caret is in (every
+//! control in Design Mode), check boxes that tick on click, and the list or calendar of a
+//! drop-down, combo box or date picker. Everything ends in a `developer.*` command.
+
+use egui::{Align2, Rect, Stroke, Ui, pos2, vec2};
+use serde_json::json;
+use wordcraft_doc::Pos;
+use wordcraft_doc::control::{ControlKind, ControlRange};
+use wordcraft_layout::DocLayout;
+
+use crate::WordApp;
+use crate::theme::{Tokens, regular};
+
+/// Most controls framed at once (Design Mode in a long form).
+const MAX_FRAMED: usize = 400;
+
+/// What the canvas remembers between frames.
+#[derive(Default)]
+pub struct ControlUi {
+    /// Clickable check boxes shown this frame: (screen rect, where the content starts).
+    checks: Vec<(Rect, Pos)>,
+    /// The list/calendar button of the control the caret is in.
+    button: Option<(Rect, Pos)>,
+    /// The open list or calendar.
+    popup: Option<Popup>,
+}
+
+struct Popup {
+    /// Content start of the control it belongs to.
+    at: Pos,
+    /// Where it hangs from (screen).
+    anchor: Rect,
+    /// Calendar month shown (year, month).
+    month: (i64, u32),
+}
+
+fn screen(pr: Rect, scale: f32, r: wordcraft_geom::Rect) -> Rect {
+    Rect::from_min_size(pos2(pr.min.x + r.x * scale, pr.min.y + r.y * scale), vec2(r.w * scale, r.h * scale))
+}
+
+/// The control's content on screen, one rect per page it is on.
+fn frames(app: &WordApp, layout: &DocLayout, rects: &[Rect], scale: f32, r: &ControlRange) -> Vec<Rect> {
+    let a = r.content_start();
+    let mut out: Vec<(usize, Rect)> = Vec::new();
+    for (pi, sr) in layout.selection_rects(&app.session.doc, &a, &r.end, app.session.page_hint) {
+        let Some(pr) = rects.get(pi) else { continue };
+        let s = screen(*pr, scale, sr);
+        match out.iter_mut().find(|(p, _)| *p == pi) {
+            Some((_, u)) => *u = u.union(s),
+            None => out.push((pi, s)),
+        }
+    }
+    if out.is_empty()
+        && let Some(c) = layout.caret_on(&a, app.session.page_hint)
+        && let Some(pr) = rects.get(c.page)
+    {
+        out.push((c.page, Rect::from_min_size(pos2(pr.min.x + c.x * scale, pr.min.y + c.top * scale), vec2(4.0, c.height * scale))));
+    }
+    out.into_iter().map(|(_, r)| r.expand2(vec2(2.0, 1.0))).collect()
+}
+
+/// Draw the frames (inside the canvas viewport, after the selection).
+pub fn paint(app: &mut WordApp, painter: &egui::Painter, t: &Tokens, layout: &DocLayout, rects: &[Rect], scale: f32) {
+    app.controls.checks.clear();
+    app.controls.button = None;
+    let story = app.session.sel.focus.story;
+    let current = app.session.doc.control_at(&app.session.sel.focus);
+    let mut shown: Vec<ControlRange> = if app.session.view.design_mode {
+        app.session.doc.control_ranges(story).into_iter().take(MAX_FRAMED).collect()
+    } else {
+        current.clone().into_iter().collect()
+    };
+    // Check boxes are clickable wherever they are, framed or not.
+    let all = if app.session.view.design_mode { shown.clone() } else { app.session.doc.control_ranges(story) };
+    for r in all.iter().filter(|r| matches!(r.control.kind, ControlKind::CheckBox { .. })).take(MAX_FRAMED) {
+        if let Some(f) = frames(app, layout, rects, scale, r).first() {
+            app.controls.checks.push((*f, r.content_start()));
+        }
+    }
+    shown.sort_by_key(|r| r.depth);
+    for r in &shown {
+        let is_current = current.as_ref().is_some_and(|c| c.start == r.start);
+        let fr = frames(app, layout, rects, scale, r);
+        let stroke = Stroke::new(1.0, if is_current { t.accent } else { t.accent.gamma_multiply(0.55) });
+        for f in &fr {
+            painter.rect_stroke(*f, 1.0, stroke, egui::StrokeKind::Outside);
+        }
+        // The title tab above the first line (its tag in Design Mode when it has no title).
+        let title = if r.control.title.is_empty() && app.session.view.design_mode { r.control.tag.as_str() } else { r.control.title.as_str() };
+        if let Some(first) = fr.first()
+            && !title.is_empty()
+        {
+            let font = regular(9.5);
+            let w = painter.layout_no_wrap(title.to_string(), font.clone(), t.accent_text).size().x + 10.0;
+            let tab = Rect::from_min_size(pos2(first.min.x, first.min.y - 14.0), vec2(w.min(320.0), 14.0));
+            painter.rect_filled(tab, egui::CornerRadius { nw: 3, ne: 3, sw: 0, se: 0 }, if is_current { t.accent } else { t.checked });
+            let ink = if is_current { t.on_accent } else { t.accent_text };
+            painter.with_clip_rect(tab).text(pos2(tab.min.x + 5.0, tab.center().y), Align2::LEFT_CENTER, title, font, ink);
+        }
+        // The list/calendar button at the right of the current one.
+        if is_current
+            && matches!(r.control.kind, ControlKind::ComboBox { .. } | ControlKind::DropDown { .. } | ControlKind::Date { .. })
+            && let Some(last) = fr.last()
+        {
+            let b = Rect::from_min_size(pos2(last.max.x + 1.0, last.min.y), vec2(14.0, last.height().max(12.0)));
+            painter.rect_filled(b, 1.0, t.checked);
+            painter.rect_stroke(b, 1.0, Stroke::new(1.0, t.accent), egui::StrokeKind::Inside);
+            let c = b.center();
+            painter.add(egui::Shape::convex_polygon(
+                vec![pos2(c.x - 3.5, c.y - 1.5), pos2(c.x + 3.5, c.y - 1.5), pos2(c.x, c.y + 2.5)],
+                t.text,
+                Stroke::NONE,
+            ));
+            app.controls.button = Some((b, r.content_start()));
+        }
+    }
+    if app.controls.popup.as_ref().is_some_and(|p| current.as_ref().is_none_or(|c| c.content_start() != p.at)) {
+        app.controls.popup = None;
+    }
+}
+
+/// After the canvas handled the pointer: a click ticks a check box or opens a list/calendar.
+pub fn clicks(app: &mut WordApp, resp: &egui::Response) {
+    if !resp.clicked() {
+        return;
+    }
+    let Some(p) = resp.interact_pointer_pos() else { return };
+    if let Some((b, at)) = app.controls.button.clone()
+        && b.contains(p)
+    {
+        let today = today();
+        let month = date_of(app, &at).map(|(y, m, _)| (y, m)).unwrap_or((today.0, today.1));
+        app.controls.popup = if app.controls.popup.is_some() { None } else { Some(Popup { at, anchor: b, month }) };
+        return;
+    }
+    if let Some((_, at)) = app.controls.checks.iter().find(|(r, _)| r.contains(p)).cloned() {
+        let at = serde_json::to_value(&at).unwrap_or_default();
+        let _ = app.run("developer.toggleCheckBox", json!({"at": at}));
+    }
+}
+
+fn date_of(app: &WordApp, at: &Pos) -> Option<(i64, u32, u32)> {
+    let r = app.session.doc.control_at(at)?;
+    match &r.control.kind {
+        ControlKind::Date { full_date, .. } => wordcraft_engine::cmd::controls::parse_date(full_date),
+        _ => None,
+    }
+}
+
+fn today() -> (i64, u32, u32) {
+    let (y, m, d) = wordcraft_engine::cmd::civil_from_days((wordcraft_engine::cmd::now_unix() / 86_400) as i64);
+    (y, m, d)
+}
+
+/// The open list or calendar (outside the canvas viewport, above everything).
+pub fn popup(app: &mut WordApp, ctx: &egui::Context) {
+    let Some(pop) = app.controls.popup.as_ref() else { return };
+    let (at, anchor) = (pop.at.clone(), pop.anchor);
+    let Some(r) = app.session.doc.control_at(&at) else {
+        app.controls.popup = None;
+        return;
+    };
+    let t = Tokens::get(ctx);
+    let at_json = serde_json::to_value(&at).unwrap_or_default();
+    let mut close = false;
+    let area = egui::Area::new(egui::Id::new("content_control_popup"))
+        .order(egui::Order::Foreground)
+        .fixed_pos(pos2(anchor.max.x - 180.0, anchor.max.y + 2.0));
+    let shown = area.show(ctx, |ui| {
+        egui::Frame::popup(ui.style()).fill(t.menu).show(ui, |ui| {
+            ui.set_min_width(180.0);
+            match &r.control.kind {
+                ControlKind::ComboBox { items, .. } | ControlKind::DropDown { items, .. } => {
+                    egui::ScrollArea::vertical().max_height(260.0).show(ui, |ui| {
+                        for (i, item) in items.iter().enumerate() {
+                            if ui.selectable_label(false, &item.display).clicked() {
+                                let _ = app.run("developer.chooseItem", json!({"at": at_json, "index": i}));
+                                close = true;
+                            }
+                        }
+                    });
+                }
+                ControlKind::Date { .. } => {
+                    if let Some(pop) = app.controls.popup.as_mut()
+                        && let Some(day) = calendar(ui, &t, &mut pop.month)
+                    {
+                        let (y, m) = pop.month;
+                        let _ = app.run("developer.setDate", json!({"at": at_json, "date": format!("{y:04}-{m:02}-{day:02}")}));
+                        close = true;
+                    }
+                    if ui.button(tl!("Today")).clicked() {
+                        let (y, m, d) = today();
+                        let _ = app.run("developer.setDate", json!({"at": at_json, "date": format!("{y:04}-{m:02}-{d:02}")}));
+                        close = true;
+                    }
+                }
+                _ => close = true,
+            }
+        });
+    });
+    let outside = ctx.input(|i| i.pointer.any_pressed())
+        && ctx.input(|i| i.pointer.interact_pos()).is_some_and(|p| !shown.response.rect.contains(p) && !anchor.contains(p));
+    if close || outside || ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
+        app.controls.popup = None;
+    }
+}
+
+/// A month grid (Monday first); returns the day clicked.
+fn calendar(ui: &mut Ui, t: &Tokens, month: &mut (i64, u32)) -> Option<u32> {
+    let (y, m) = *month;
+    let mut picked = None;
+    ui.horizontal(|ui| {
+        if ui.small_button("‹").clicked() {
+            *month = if m == 1 { (y - 1, 12) } else { (y, m - 1) };
+        }
+        ui.label(egui::RichText::new(format!("{y:04}-{m:02}")).strong());
+        if ui.small_button("›").clicked() {
+            *month = if m == 12 { (y + 1, 1) } else { (y, m + 1) };
+        }
+    });
+    let (y, m) = (y.clamp(1, 9999), m.clamp(1, 12));
+    let first = wordcraft_engine::cmd::controls::days_from_civil(y, m, 1);
+    // 1970-01-01 was a Thursday: Monday-first column of the 1st.
+    let lead = (first + 3).rem_euclid(7) as u32;
+    let days = wordcraft_engine::cmd::controls::days_in_month(y, m);
+    egui::Grid::new("cc_calendar").spacing(vec2(2.0, 2.0)).show(ui, |ui| {
+        for cell in 0..(lead + days) {
+            if cell < lead {
+                ui.label("");
+            } else {
+                let d = cell - lead + 1;
+                let b = egui::Button::new(egui::RichText::new(d.to_string()).color(t.text)).min_size(vec2(22.0, 18.0));
+                if ui.add(b).clicked() {
+                    picked = Some(d);
+                }
+            }
+            if (cell + 1) % 7 == 0 {
+                ui.end_row();
+            }
+        }
+    });
+    picked
+}
diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rs
index a9c171b057..c011f68a3a 100644
--- a/crates/ui-egui/src/control.rs
+++ b/crates/ui-egui/src/control.rs
@@ -8,7 +8,8 @@
 //!   real pointer input in screen points (reaches every widget)
 //! - `ui.clickText {page, x, y}`: click at a page position (points from the page's top-left)
 //! - `ui.key {key, shift?, alt?, cmd?}`, `ui.text {text}`: keyboard input through egui
-//! - `ui.screenshot {path?}`: PNG of the window; `ui.render {path, page?, scale?}`: page PNG
+//! - `ui.screenshot {path?}`: PNG of the window; `ui.render {path?, page?, scale?}`: page PNG
+//!   (without `path`, both reply with the PNG as base64 `png`)
 //! - `ui.parity`: feature catalog parity
 
 use std::sync::mpsc::Sender;
@@ -203,11 +204,19 @@ pub fn handle(app: &mut WordApp, ctx: &egui::Context, req: &ControlRequest) -> O
         }
         "ui.screenshot" => Outcome::Screenshot { path: s("path").map(str::to_string) },
         "ui.render" => {
-            let path = s("path").unwrap_or("/tmp/wordcraft-page.png");
             let page = p.get("page").and_then(Value::as_u64).unwrap_or(1);
-            match app.session.run("file.exportPng", &json!({"path": path, "page": page, "scale": f("scale").unwrap_or(2.0)})) {
-                Ok(v) => ok(v),
-                Err(e) => err(e),
+            let scale = f("scale").unwrap_or(2.0);
+            match s("path") {
+                Some(path) => match app.session.run("file.exportPng", &json!({"path": path, "page": page, "scale": scale})) {
+                    Ok(v) => ok(v),
+                    Err(e) => err(e),
+                },
+                // No path: the PNG travels in the reply. Never a fixed name in the shared
+                // temporary folder, where another user could have planted a link to a file.
+                None => match render_png(app, page, scale) {
+                    Ok(v) => ok(v),
+                    Err(e) => err(e),
+                },
             }
         }
         "ui.resize" => {
@@ -234,12 +243,27 @@ pub fn handle(app: &mut WordApp, ctx: &egui::Context, req: &ControlRequest) -> O
     }
 }
 
+/// A page rendered by the engine, as base64 PNG in the reply (the same shape as the headless
+/// MCP server's `ui.render`).
+fn render_png(app: &WordApp, page: u64, scale: f32) -> Result<Value, String> {
+    let page = usize::try_from(page.max(1)).unwrap_or(usize::MAX).saturating_sub(1);
+    let l = app.session.export_layout();
+    let pg = l.pages.get(page).ok_or_else(|| format!("no page {}", page + 1))?;
+    let img = wordcraft_render::render_page(&app.session.doc, pg, scale.clamp(0.1, 8.0), &Default::default());
+    let png = img.to_png();
+    Ok(json!({"png": wordcraft_engine::cmd::insert::base64_encode(&png), "width": img.width, "height": img.height, "pages": l.pages.len()}))
+}
+
+/// The window screenshot: written to `path` when one was given, else base64 PNG in the reply
+/// (never a fixed name in the shared temporary folder).
 pub fn save_screenshot(image: &egui::ColorImage, path: Option<&str>) -> Value {
-    let path = path.unwrap_or("/tmp/wordcraft-screenshot.png");
     let [w, h] = image.size;
     let bytes: Vec<u8> = image.pixels.iter().flat_map(|c| c.to_array()).collect();
     let rendered = wordcraft_render::Rendered { width: w as u32, height: h as u32, pixels: bytes };
     let png = rendered.to_png();
+    let Some(path) = path else {
+        return json!({"ok": true, "result": {"png": wordcraft_engine::cmd::insert::base64_encode(&png), "width": w, "height": h}});
+    };
     #[cfg(target_arch = "wasm32")]
     let _ = (&png, path);
     #[cfg(not(target_arch = "wasm32"))]
diff --git a/crates/ui-egui/src/dialogs.rs b/crates/ui-egui/src/dialogs.rs
index ff6f01b3be..d6654a8849 100644
--- a/crates/ui-egui/src/dialogs.rs
+++ b/crates/ui-egui/src/dialogs.rs
@@ -15,11 +15,121 @@ use wordcraft_engine::Password;
 use crate::WordApp;
 use crate::theme::{Tokens, semibold};
 
+/// The Find and Replace dialog's search options beyond the first row (#543).
+#[derive(Clone, Debug, Default, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct FindExtra {
+    pub wildcards: bool,
+    pub prefix: bool,
+    pub suffix: bool,
+    pub ignore_punct: bool,
+    pub ignore_space: bool,
+    /// The search options are shown.
+    pub more: bool,
+    /// Special ▾ inserts into Replace with (it last had the focus), not Find what.
+    pub to_replace: bool,
+}
+
+/// The Special ▾ menu: (name, code) for Find what, without and with wildcards.
+const SPECIAL_FIND: &[(&str, &str)] = &[
+    ("Paragraph Mark", "^p"),
+    ("Tab Character", "^t"),
+    ("Any Character", "^?"),
+    ("Any Digit", "^#"),
+    ("Any Letter", "^$"),
+    ("Caret Character", "^^"),
+    ("Section Character", "^%"),
+    ("Paragraph Character", "^v"),
+    ("Column Break", "^n"),
+    ("Em Dash", "^+"),
+    ("En Dash", "^="),
+    ("Graphic", "^g"),
+    ("Manual Line Break", "^l"),
+    ("Manual Page Break", "^m"),
+    ("Nonbreaking Hyphen", "^~"),
+    ("Nonbreaking Space", "^s"),
+    ("Optional Hyphen", "^-"),
+    ("Section Break", "^b"),
+    ("White Space", "^w"),
+];
+const SPECIAL_FIND_WILD: &[(&str, &str)] = &[
+    ("Any Character", "?"),
+    ("Character in Range", "[-]"),
+    ("Beginning of Word", "<"),
+    ("End of Word", ">"),
+    ("Expression", "()"),
+    ("Not", "[!]"),
+    ("Num Occurrences", "{,}"),
+    ("Previous 1 or More", "@"),
+    ("0 or More Characters", "*"),
+    ("Paragraph Mark", "^13"),
+    ("Tab Character", "^t"),
+    ("Caret Character", "^^"),
+    ("Section Character", "^%"),
+    ("Paragraph Character", "^v"),
+    ("Column Break", "^n"),
+    ("Em Dash", "^+"),
+    ("En Dash", "^="),
+    ("Graphic", "^g"),
+    ("Manual Line Break", "^l"),
+    ("Manual Page Break", "^m"),
+    ("Nonbreaking Hyphen", "^~"),
+    ("Nonbreaking Space", "^s"),
+    ("Optional Hyphen", "^-"),
+];
+/// Replace with; with wildcards, "Find What Expression" (`\1`) comes first.
+const SPECIAL_REPLACE: &[(&str, &str)] = &[
+    ("Paragraph Mark", "^p"),
+    ("Tab Character", "^t"),
+    ("Caret Character", "^^"),
+    ("Section Character", "^%"),
+    ("Paragraph Character", "^v"),
+    ("Clipboard Contents", "^c"),
+    ("Column Break", "^n"),
+    ("Em Dash", "^+"),
+    ("En Dash", "^="),
+    ("Find What Text", "^&"),
+    ("Manual Line Break", "^l"),
+    ("Manual Page Break", "^m"),
+    ("Nonbreaking Hyphen", "^~"),
+    ("Nonbreaking Space", "^s"),
+    ("Optional Hyphen", "^-"),
+];
+
+/// The Special ▾ menu button; returns the code picked.
+fn special_menu(ui: &mut Ui, extra: &FindExtra) -> Option<&'static str> {
+    let mut picked = None;
+    ui.menu_button(format!("{} ▾", tl!("Special")), |ui| {
+        let wild_replace: &[(&str, &str)] = &[("Find What Expression", "\\1")];
+        let lists: [&[(&str, &str)]; 2] = match (extra.to_replace, extra.wildcards) {
+            (false, false) => [SPECIAL_FIND, &[]],
+            (false, true) => [SPECIAL_FIND_WILD, &[]],
+            (true, false) => [SPECIAL_REPLACE, &[]],
+            (true, true) => [wild_replace, SPECIAL_REPLACE],
+        };
+        for (name, code) in lists.into_iter().flatten() {
+            if ui.button(format!("{}   {code}", tl!(name))).clicked() {
+                picked = Some(*code);
+                ui.close();
+            }
+        }
+    });
+    picked
+}
+
 #[derive(Clone, Debug, Serialize)]
 #[serde(tag = "dialog", rename_all = "camelCase")]
 pub enum Dialog {
     Font {
+        /// The font (Latin text) and the Asian text font, as the font lists name them, and their
+        /// values when the dialog opened: OK changes only the ones changed (#505).
         font: String,
+        font_was: String,
+        font_ea: String,
+        font_ea_was: String,
+        /// Show the Asian text font box: a Chinese or Japanese interface, or East Asian text or
+        /// an Asian font in the selection.
+        asian: bool,
         size: String,
         bold: bool,
         italic: bool,
@@ -32,6 +142,11 @@ pub enum Dialog {
         hidden: bool,
         color: String,
         spacing: f32,
+        /// The properties the fields stood for when the dialog opened: OK sends only what the
+        /// user changed, so formatting the dialog can't show (a double underline) or left
+        /// alone stays as it is.
+        #[serde(skip)]
+        start: serde_json::Map<String, Value>,
     },
     Paragraph {
         /// Right-to-left reading order (Direction in Word's Paragraph dialog).
@@ -44,7 +159,12 @@ pub enum Dialog {
         first: f32,
         before: f32,
         after: f32,
+        /// Line spacing as a multiple; Exactly and At Least show as 1.0.
         line: f32,
+        /// `line` when the dialog opened: OK keeps the paragraph's spacing, whatever its rule,
+        /// unless this changed (#467).
+        #[serde(skip)]
+        line_was: f32,
         keep_next: bool,
         keep_lines: bool,
         page_break: bool,
@@ -58,6 +178,12 @@ pub enum Dialog {
         /// `asian` when the dialog opened: OK sets only the flags that changed.
         #[serde(skip)]
         asian_was: [bool; 6],
+        /// Mirror indents, don't add space between paragraphs of the same style, suppress line
+        /// numbers, don't hyphenate (#512).
+        opts: [bool; 4],
+        /// `opts` when the dialog opened: OK sets only the ones that changed.
+        #[serde(skip)]
+        opts_was: [bool; 4],
     },
     /// Tabs (#320).
     Tabs {
@@ -73,6 +199,8 @@ pub enum Dialog {
         match_case: bool,
         whole_word: bool,
         regex: bool,
+        /// Search options under "Search Options" (#543).
+        extra: FindExtra,
         replace_mode: bool,
         message: String,
     },
@@ -134,6 +262,9 @@ pub enum Dialog {
     ModifyStyle {
         #[serde(skip)]
         back: bool,
+        /// The dialog that comes back when this closes (Table of Contents › Modify…).
+        #[serde(skip)]
+        resume: Option<Box<Dialog>>,
         id: String,
         name: String,
         font: String,
@@ -157,7 +288,7 @@ pub enum Dialog {
         name: String,
         /// Style id.
         based_on: String,
-        /// Index into `regions` (see [`REGION_LABELS`]).
+        /// Index into `regions` (see `REGION_LABELS`).
         region: usize,
         regions: Box<[TableRegion; 7]>,
         /// What the regions showed when the dialog opened (or the base style changed): only
@@ -170,6 +301,9 @@ pub enum Dialog {
     },
     /// Columns, Symbol and Field ([`crate::dialogs_insert`], #321).
     Insert(Box<crate::dialogs_insert::InsertDialog>),
+    /// Caption, Index, Mark Index Entry, Table of Contents, Source Manager and Create / Edit
+    /// Source ([`crate::dialogs_refs`], #402).
+    Refs(Box<crate::dialogs_refs::RefsDialog>),
     /// Insert › Icons: the icon library, searchable and filtered by category (empty for all).
     Icons {
         query: String,
@@ -289,6 +423,8 @@ pub enum Dialog {
     TrackOptions {
         form: Box<crate::dialogs_lists::TrackForm>,
     },
+    /// Compare / Combine Documents and AutoCorrect Options ([`crate::dialogs_review`], #412).
+    Review(Box<crate::dialogs_review::ReviewDialog>),
     /// Tools › Customize Keyboard (#368).
     CustomizeKeyboard {
         form: Box<crate::dialogs_keyboard::KeyboardForm>,
@@ -297,6 +433,10 @@ pub enum Dialog {
     CustomizeRibbon {
         form: Box<crate::dialogs_ribbon::RibbonForm>,
     },
+    /// Developer › Controls › Properties.
+    Control {
+        form: Box<crate::dialogs_controls::ControlForm>,
+    },
     /// Home › Font › Enclose Characters: the style (`none` takes the enclosure away, `shrink`,
     /// `enlarge`), the text and the shape (`circle`, `square`, `triangle`, `diamond`).
     Enclose {
@@ -308,6 +448,16 @@ pub enum Dialog {
     NoteOptions {
         form: Box<crate::dialogs_notes::NoteForm>,
     },
+    /// View › Templates › Templates and Add-ins (#377).
+    Templates {
+        form: Box<crate::dialogs_templates::TemplatesForm>,
+    },
+    /// Templates and Add-ins › Organizer: copy, delete and rename styles (#377).
+    Organizer {
+        form: Box<crate::dialogs_templates::OrganizerForm>,
+    },
+    /// Line Numbers, Hyphenation, Language, Envelopes and Labels (#407).
+    Layout(Box<crate::dialogs_layout::LayoutDialog>),
 }
 
 /// The Table Properties dialog's fields. Lengths are in the interface unit
@@ -341,7 +491,7 @@ impl TableForm {
         let s = &app.session;
         let (tp, r, c) = s.sel.focus.path.cell()?;
         let t = s.doc.table(s.sel.focus.story, &tp)?;
-        let k = wordcraft_geom::Unit::default().pt_per_unit();
+        let k = crate::options::unit().pt_per_unit();
         let row = t.rows.get(r).map(|x| x.props.clone()).unwrap_or_default();
         let cell = t.rows.get(r).and_then(|x| x.cells.get(c)).map(|x| x.props.clone()).unwrap_or_default();
         let tw = wordcraft_engine::cmd::page::sect(s).text_width();
@@ -377,7 +527,7 @@ impl TableForm {
 
     /// `table.properties` parameters for what differs from `basis` (empty when nothing does).
     pub fn changes(&self, basis: &TableForm) -> Value {
-        let k = wordcraft_geom::Unit::default().pt_per_unit();
+        let k = crate::options::unit().pt_per_unit();
         let moved = |a: f32, b: f32| (a - b).abs() > 1e-4;
         let mut v = serde_json::Map::new();
         if self.width_on != basis.width_on || (self.width_on && moved(self.width, basis.width)) {
@@ -653,8 +803,16 @@ fn region_changes(r: &TableRegion, basis: &TableRegion) -> Value {
 
 /// A colour menu: a swatch with the colour grid and No Color. `value` is hex, empty for none.
 pub(crate) fn color_menu(ui: &mut Ui, theme: &[wordcraft_doc::Rgb], value: &mut String) {
-    let c = wordcraft_doc::Rgb::parse(value);
+    color_field(ui, theme, value, "No Color", "");
+}
+
+/// A colour field: a swatch and a drop-down with `none_label` (which sets `none_value`), the
+/// colour grid, Recent Colors and More Colors… (#606). `value` is hex or `none_value`.
+pub(crate) fn color_field(ui: &mut Ui, theme: &[wordcraft_doc::Rgb], value: &mut String, none_label: &str, none_value: &str) {
     ui.horizontal(|ui| {
+        let id = ui.id().with("colorField");
+        crate::colors::take_field(ui.ctx(), id, value);
+        let c = wordcraft_doc::Rgb::parse(value);
         let (r, _) = ui.allocate_exact_size(vec2(16.0, 16.0), Sense::hover());
         let t = Tokens::get(ui.ctx());
         match c {
@@ -666,16 +824,13 @@ pub(crate) fn color_menu(ui: &mut Ui, theme: &[wordcraft_doc::Rgb], value: &mut
             }
         }
         ui.painter().rect_stroke(r, 2.0, egui::Stroke::new(1.0, t.border_strong), egui::StrokeKind::Inside);
-        let label = if c.is_some() { value.clone() } else { tl!("No Color").to_string() };
+        let label = if c.is_some() { value.clone() } else { tl!(none_label).to_string() };
         ui.menu_button(label, |ui| {
-            if ui.button(tl!("No Color")).clicked() {
-                value.clear();
-                ui.close();
-            }
-            if let Some(hex) = crate::widgets::color_grid(ui, theme) {
-                *value = hex;
+            if ui.button(tl!(none_label)).clicked() {
+                *value = none_value.to_string();
                 ui.close();
             }
+            crate::colors::field_menu(ui, theme, id, value);
         });
     });
 }
@@ -705,6 +860,7 @@ impl Dialog {
             Dialog::TableStyle { .. } => "modifyTableStyle",
             Dialog::Commands { .. } => "commands",
             Dialog::Insert(d) => d.name(),
+            Dialog::Refs(d) => d.name(),
             Dialog::Icons { .. } => "icons",
             Dialog::PasteSpecial { .. } => "pasteSpecial",
             Dialog::About { .. } => "about",
@@ -724,10 +880,15 @@ impl Dialog {
             Dialog::EncryptPassword { .. } => "encryptPassword",
             Dialog::DefineList { .. } => "defineList",
             Dialog::TrackOptions { .. } => "trackChangesOptions",
+            Dialog::Review(d) => d.name(),
             Dialog::CustomizeKeyboard { .. } => "customizeKeyboard",
             Dialog::CustomizeRibbon { .. } => "customizeRibbon",
+            Dialog::Control { .. } => "controlProperties",
             Dialog::Enclose { .. } => "enclose",
             Dialog::NoteOptions { .. } => "noteOptions",
+            Dialog::Templates { .. } => "templates",
+            Dialog::Organizer { .. } => "organizer",
+            Dialog::Layout(d) => d.name(),
         }
     }
 
@@ -751,25 +912,56 @@ impl Dialog {
         if let Some(d) = crate::dialogs_insert::open(name, app) {
             return Some(Dialog::Insert(Box::new(d)));
         }
+        if let Some(d) = crate::dialogs_refs::open(name, app) {
+            return Some(Dialog::Refs(Box::new(d)));
+        }
+        if let Some(d) = crate::dialogs_layout::open(name, app) {
+            return Some(Dialog::Layout(Box::new(d)));
+        }
+        if matches!(name, "compare" | "combine" | "autoCorrect" | "restrictEditing") {
+            return crate::dialogs_review::open(name, app).map(|d| Dialog::Review(Box::new(d)));
+        }
         let st = app.session.run("format.state", &json!({})).unwrap_or_default();
         let s = |k: &str| st.get(k).and_then(Value::as_str).unwrap_or("").to_string();
         let b = |k: &str| st.get(k).and_then(Value::as_bool).unwrap_or(false);
         Some(match name {
-            "font" => Dialog::Font {
-                font: s("font"),
-                size: st.get("size").and_then(Value::as_f64).map(|v| v.to_string()).unwrap_or_default(),
-                bold: b("bold"),
-                italic: b("italic"),
-                underline: b("underline"),
-                strike: b("strike"),
-                sup: b("superscript"),
-                sub: b("subscript"),
-                small_caps: false,
-                caps: false,
-                hidden: false,
-                color: s("color"),
-                spacing: 0.0,
-            },
+            "font" => {
+                let font = app.previews.font_shown(&s("font"));
+                let font_ea = app.previews.font_shown(&s("fontEastAsia"));
+                let lang = crate::i18n::current().code();
+                let text = app.session.selected_text();
+                let text = if text.is_empty() {
+                    app.session.doc.para_at(&app.session.sel.focus).map(|p| p.plain_text().to_string()).unwrap_or_default()
+                } else {
+                    text
+                };
+                let asian = ["zh", "ja", "ko"].iter().any(|l| lang.starts_with(l)) || !font_ea.is_empty() || text.chars().any(east_asian_char);
+                let mut d = Dialog::Font {
+                    font_was: font.clone(),
+                    font,
+                    font_ea_was: font_ea.clone(),
+                    font_ea,
+                    asian,
+                    size: st.get("size").and_then(Value::as_f64).map(|v| v.to_string()).unwrap_or_default(),
+                    bold: b("bold"),
+                    italic: b("italic"),
+                    underline: b("underline"),
+                    strike: b("strike"),
+                    sup: b("superscript"),
+                    sub: b("subscript"),
+                    small_caps: b("smallCaps"),
+                    caps: b("caps"),
+                    hidden: b("hidden"),
+                    color: s("color"),
+                    spacing: st.get("spacing").and_then(Value::as_f64).unwrap_or(0.0) as f32,
+                    start: serde_json::Map::new(),
+                };
+                let props = font_props(&d);
+                if let Dialog::Font { start, .. } = &mut d {
+                    *start = props;
+                }
+                d
+            }
             "paragraph" | "asianTypography" => {
                 let rp = app.session.doc.para_at(&app.session.sel.focus).map(|p| app.session.doc.styles.resolve_para(&p.props));
                 let rp = rp?;
@@ -781,12 +973,13 @@ impl Dialog {
                 Dialog::Paragraph {
                     rtl: rp.bidi,
                     align: format!("{:?}", rp.align.visual(rp.bidi)).to_lowercase(),
-                    left: vl / 72.0,
-                    right: vr / 72.0,
-                    first: rp.indent_first / 72.0,
+                    left: vl / crate::options::unit().pt_per_unit(),
+                    right: vr / crate::options::unit().pt_per_unit(),
+                    first: rp.indent_first / crate::options::unit().pt_per_unit(),
                     before: rp.space_before,
                     after: rp.space_after,
                     line,
+                    line_was: line,
                     keep_next: rp.keep_next,
                     keep_lines: rp.keep_lines,
                     page_break: rp.page_break_before,
@@ -794,6 +987,8 @@ impl Dialog {
                     tab: if name == "asianTypography" { 2 } else { 0 },
                     asian: [rp.kinsoku, rp.word_wrap, rp.overflow_punct, rp.top_line_punct, rp.auto_space_de, rp.auto_space_dn],
                     asian_was: [rp.kinsoku, rp.word_wrap, rp.overflow_punct, rp.top_line_punct, rp.auto_space_de, rp.auto_space_dn],
+                    opts: [rp.mirror_indents, rp.contextual_spacing, rp.suppress_line_numbers, rp.suppress_hyphens],
+                    opts_was: [rp.mirror_indents, rp.contextual_spacing, rp.suppress_line_numbers, rp.suppress_hyphens],
                 }
             }
             "tabs" => Dialog::Tabs { form: Box::new(crate::dialogs_para::TabsForm::read(app)?) },
@@ -811,6 +1006,19 @@ impl Dialog {
                 match_case: app.session.find.match_case,
                 whole_word: app.session.find.whole_word,
                 regex: app.session.find.regex,
+                extra: FindExtra {
+                    wildcards: app.session.find.wildcards,
+                    prefix: app.session.find.match_prefix,
+                    suffix: app.session.find.match_suffix,
+                    ignore_punct: app.session.find.ignore_punct,
+                    ignore_space: app.session.find.ignore_space,
+                    more: app.session.find.wildcards
+                        || app.session.find.match_prefix
+                        || app.session.find.match_suffix
+                        || app.session.find.ignore_punct
+                        || app.session.find.ignore_space,
+                    to_replace: false,
+                },
                 replace_mode: name == "replace",
                 message: String::new(),
             },
@@ -828,10 +1036,10 @@ impl Dialog {
                 let size = app.session.doc.styles.resolve_char(Some("Normal"), &Default::default()).size;
                 let grid = (kind, sp.grid_lines_per_page().min(1000), sp.grid_chars_per_line(size).min(1000));
                 Dialog::PageSetup {
-                    top: sp.margin_top / 72.0,
-                    bottom: sp.margin_bottom / 72.0,
-                    left: sp.margin_left / 72.0,
-                    right: sp.margin_right / 72.0,
+                    top: sp.margin_top / crate::options::unit().pt_per_unit(),
+                    bottom: sp.margin_bottom / crate::options::unit().pt_per_unit(),
+                    left: sp.margin_left / crate::options::unit().pt_per_unit(),
+                    right: sp.margin_right / crate::options::unit().pt_per_unit(),
                     landscape: sp.landscape,
                     grid,
                     grid_was: grid,
@@ -939,6 +1147,15 @@ impl Dialog {
                 Dialog::CustomizeRibbon { form: Box::new(crate::dialogs_ribbon::RibbonForm::read(app, crate::dialogs_ribbon::Page::QuickAccess)) }
             }
             "noteOptions" => Dialog::NoteOptions { form: Box::new(crate::dialogs_notes::NoteForm::read(app)) },
+            "templates" => Dialog::Templates { form: Box::new(crate::dialogs_templates::TemplatesForm::read(app)) },
+            "organizer" => Dialog::Organizer { form: Box::new(crate::dialogs_templates::OrganizerForm::read(app, None)) },
+            "controlProperties" => match crate::dialogs_controls::ControlForm::read(app) {
+                Some(form) => Dialog::Control { form: Box::new(form) },
+                None => {
+                    app.status(tl!("Put the caret in a content control first."));
+                    return None;
+                }
+            },
             _ => return None,
         })
     }
@@ -967,6 +1184,7 @@ impl Dialog {
         let rp = app.session.doc.styles.resolve_para(&wordcraft_doc::ParaProps { style: Some(id.into()), ..Default::default() });
         Some(Dialog::ModifyStyle {
             back: false,
+            resume: None,
             id: id.into(),
             name: st.name.clone(),
             font: rc.font,
@@ -1024,35 +1242,41 @@ pub fn table_grid_picker(ui: &mut Ui, app: &mut WordApp) {
     }
 }
 
-/// Where the open dialog's top edge sits, as (window id, offset below the top of the screen).
+/// The open dialog, as (window id, frames it has been centred for).
 fn dialog_top_key() -> egui::Id {
     egui::Id::new("dialog_top")
 }
 
-/// Anchors a dialog: centred on the frame it opens, then with its top edge held where that put
-/// it, so a taller or shorter tab (Paragraph, Font, Borders and Shading…) only moves the bottom
-/// edge and the tab strip stays under the mouse (#507). egui keeps it on screen if it grows past
-/// the bottom.
+/// Frames a dialog stays centred: the first one measures it, the second centres that size.
+const DIALOG_CENTRED_FRAMES: u8 = 2;
+
+/// Places a dialog: centred for its first frames, then left where it is with its top-centre point
+/// as the pivot, so a taller or shorter tab (Paragraph, Font, Borders and Shading…) only moves
+/// the bottom edge and the tab strip stays under the mouse (#507). It is no longer anchored after
+/// that, so dragging the title bar moves it (#732). egui keeps it on screen if it grows past the
+/// bottom.
 fn place_dialog<'a>(ctx: &egui::Context, id: egui::Id, w: egui::Window<'a>) -> egui::Window<'a> {
-    match ctx.data(|d| d.get_temp::<(egui::Id, f32)>(dialog_top_key())) {
-        Some((open, top)) if open == id => w.anchor(egui::Align2::CENTER_TOP, vec2(0.0, top)),
+    let w = w.pivot(egui::Align2::CENTER_TOP);
+    match ctx.data(|d| d.get_temp::<(egui::Id, u8)>(dialog_top_key())) {
+        Some((open, frames)) if open == id && frames >= DIALOG_CENTRED_FRAMES => w,
         _ => w.anchor(egui::Align2::CENTER_CENTER, vec2(0.0, -40.0)),
     }
 }
 
-/// After a dialog's first frame: holds its top edge where centring its measured size put it.
-fn remember_dialog_top(ctx: &egui::Context, id: egui::Id, rect: egui::Rect) {
-    if ctx.data(|d| d.get_temp::<(egui::Id, f32)>(dialog_top_key())).is_some_and(|(open, _)| open == id) {
-        return;
+/// After a frame of a dialog: counts the frames it has been centred for.
+fn count_dialog_frame(ctx: &egui::Context, id: egui::Id) {
+    let frames = match ctx.data(|d| d.get_temp::<(egui::Id, u8)>(dialog_top_key())) {
+        Some((open, frames)) if open == id => frames,
+        _ => 0,
+    };
+    if frames < DIALOG_CENTRED_FRAMES {
+        ctx.data_mut(|d| d.insert_temp(dialog_top_key(), (id, frames + 1)));
     }
-    let screen = ctx.content_rect();
-    let top = (screen.center().y - 40.0 - rect.height() / 2.0 - screen.top()).max(0.0);
-    ctx.data_mut(|d| d.insert_temp(dialog_top_key(), (id, top)));
 }
 
 pub fn show(app: &mut WordApp, ctx: &egui::Context) {
     let Some(mut d) = app.dialog.take() else {
-        ctx.data_mut(|d| d.remove::<(egui::Id, f32)>(dialog_top_key()));
+        ctx.data_mut(|d| d.remove::<(egui::Id, u8)>(dialog_top_key()));
         return;
     };
     let mut open = true;
@@ -1080,6 +1304,7 @@ pub fn show(app: &mut WordApp, ctx: &egui::Context) {
         Dialog::TableStyle { .. } => "Modify Table Style",
         Dialog::Commands { .. } => "Search Commands",
         Dialog::Insert(d) => d.title(),
+        Dialog::Refs(d) => d.title(),
         Dialog::Icons { .. } => "Icons",
         Dialog::PasteSpecial { .. } => "Paste Special",
         Dialog::About { .. } => "About WordCraft",
@@ -1099,18 +1324,23 @@ pub fn show(app: &mut WordApp, ctx: &egui::Context) {
         Dialog::EncryptPassword { .. } => "Encrypt with Password",
         Dialog::DefineList { .. } => "Define New Multilevel List",
         Dialog::TrackOptions { .. } => "Track Changes Options",
+        Dialog::Review(d) => d.title(),
         Dialog::CustomizeKeyboard { .. } => "Customize Keyboard",
         Dialog::CustomizeRibbon { .. } => "Customize Ribbon",
+        Dialog::Control { .. } => "Content Control Properties",
         Dialog::Enclose { .. } => "Enclose Characters",
         Dialog::NoteOptions { .. } => "Footnote and Endnote",
+        Dialog::Templates { .. } => "Templates and Add-ins",
+        Dialog::Organizer { .. } => "Organizer",
+        Dialog::Layout(d) => d.title(),
     };
     let id = egui::Id::new(("dialog", title));
     let shown = place_dialog(ctx, id, egui::Window::new(tl!(title)).id(id).collapsible(false).resizable(false)).open(&mut open).show(ctx, |ui| {
         ui.set_min_width(340.0);
         close = body(app, ui, &mut d);
     });
-    if let Some(r) = shown {
-        remember_dialog_top(ctx, id, r.response.rect);
+    if shown.is_some() {
+        count_dialog_frame(ctx, id);
     }
     if open && !close {
         app.dialog = Some(d);
@@ -1124,11 +1354,13 @@ pub(crate) fn buttons(ui: &mut Ui, ok: &str) -> (bool, bool) {
     ui.add_space(8.0);
     ui.horizontal(|ui| {
         ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
-            if ui.button(tl!("Cancel")).clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+            // Enter and Escape belong to the Colors dialog while it is open above this one.
+            let keys = !crate::colors::is_open(ui.ctx());
+            if ui.button(tl!("Cancel")).clicked() || (keys && ui.input(|i| i.key_pressed(egui::Key::Escape))) {
                 r.1 = true;
             }
             let okb = ui.add(egui::Button::new(egui::RichText::new(ok).color(egui::Color32::WHITE)).fill(crate::theme::APP_COLOR));
-            if okb.clicked() || ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+            if okb.clicked() || (keys && ui.input(|i| i.key_pressed(egui::Key::Enter))) {
                 r.0 = true;
             }
         });
@@ -1136,10 +1368,75 @@ pub(crate) fn buttons(ui: &mut Ui, ok: &str) -> (bool, bool) {
     r
 }
 
+/// The character properties the Font dialog's fields stand for.
+fn font_props(d: &Dialog) -> serde_json::Map<String, Value> {
+    let Dialog::Font { font, font_ea, size, bold, italic, underline, strike, sup, sub, small_caps, caps, hidden, color, spacing, .. } = d else {
+        return serde_json::Map::new();
+    };
+    let mut props = serde_json::Map::new();
+    props.insert("bold".into(), json!(*bold));
+    props.insert("italic".into(), json!(*italic));
+    props.insert("strike".into(), json!(*strike));
+    props.insert("underline".into(), json!(if *underline { "single" } else { "none" }));
+    let vert = if *sup {
+        "superscript"
+    } else if *sub {
+        "subscript"
+    } else {
+        "baseline"
+    };
+    props.insert("vertAlign".into(), json!(vert));
+    props.insert("smallCaps".into(), json!(*small_caps));
+    props.insert("caps".into(), json!(*caps));
+    props.insert("hidden".into(), json!(*hidden));
+    props.insert("spacing".into(), json!(*spacing));
+    if !font.trim().is_empty() {
+        props.insert("font".into(), json!(font.trim()));
+    }
+    if !font_ea.trim().is_empty() {
+        props.insert("fontEa".into(), json!(font_ea.trim()));
+    }
+    if let Ok(s) = size.trim().parse::<f64>() {
+        props.insert("size".into(), json!(s));
+    }
+    if let Some(c) = wordcraft_doc::Rgb::parse(color) {
+        props.insert("color".into(), json!({"Rgb": [c.0, c.1, c.2]}));
+    } else if color.eq_ignore_ascii_case("auto") {
+        // Automatic, from the colour field's drop-down (#606).
+        props.insert("color".into(), json!("Auto"));
+    }
+    props
+}
+
+/// Is `c` Chinese, Japanese or Korean text (ideographs, kana, Hangul, CJK punctuation, fullwidth
+/// forms)?
+fn east_asian_char(c: char) -> bool {
+    matches!(u32::from(c), 0x1100..=0x11FF | 0x2E80..=0x9FFF | 0xA960..=0xA97F | 0xAC00..=0xD7FF | 0xF900..=0xFAFF | 0xFE30..=0xFE4F | 0xFF00..=0xFFEF | 0x20000..=0x3FFFF)
+}
+
+/// The Font dialog's OK: one formatting step that sets only the properties the user changed, so
+/// formatting the dialog can't show or left alone stays as it is. Fonts are set by their stored
+/// (English) names, the Latin font for Persian/Arabic text too (as `format.font`).
+fn apply_font(app: &mut WordApp, d: &Dialog) {
+    let Dialog::Font { start, .. } = d else { return };
+    let mut changed: serde_json::Map<String, Value> = font_props(d).into_iter().filter(|(k, v)| start.get(k) != Some(v)).collect();
+    if let Some(f) = changed.get("font").and_then(Value::as_str).map(str::to_string) {
+        let f = app.previews.font_stored(&f);
+        changed.insert("font".into(), json!(f));
+        changed.insert("fontCs".into(), json!(f));
+    }
+    if let Some(f) = changed.get("fontEa").and_then(Value::as_str).map(str::to_string) {
+        changed.insert("fontEa".into(), json!(app.previews.font_stored(&f)));
+    }
+    if !changed.is_empty() {
+        let _ = app.run("format.set", json!({"props": changed}));
+    }
+}
+
 /// Returns true to close.
 fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
     match d {
-        Dialog::Font { font, size, bold, italic, underline, strike, sup, sub, small_caps, caps, hidden, color, spacing } => {
+        Dialog::Font { font, font_ea, asian, size, bold, italic, underline, strike, sup, sub, small_caps, caps, hidden, color, spacing, .. } => {
             // Build the sample text format for the preview pane below.
             let preview_size = size.trim().parse::<f32>().unwrap_or(12.0).clamp(6.0, 72.0);
             let preview_color = wordcraft_doc::Rgb::parse(color).map(crate::theme::c32).unwrap_or_else(|| ui.visuals().text_color());
@@ -1161,14 +1458,29 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
                 fmt.strikethrough = egui::Stroke::new(1.0, preview_color);
             }
             egui::Grid::new("fontdlg").num_columns(2).spacing(vec2(10.0, 6.0)).show(ui, |ui| {
-                ui.label(tl!("Font:"));
-                ui.text_edit_singleline(font);
+                // Word's two font boxes when East Asian text is in use: the Latin text font and
+                // the Asian text font, each with its own list (type to find a font).
+                let prev = app.previews.font_preview_fn();
+                if *asian {
+                    ui.label(tl!("Asian text font:"));
+                    let fams = app.previews.east_asian_families();
+                    if let Some(f) = crate::widgets::font_combo(ui, "fontdlg_asian", 220.0, font_ea, &fams, Some(&*prev)) {
+                        *font_ea = f;
+                    }
+                    ui.end_row();
+                }
+                ui.label(if *asian { tl!("Latin text font:") } else { tl!("Font:") });
+                let fams = app.previews.families();
+                if let Some(f) = crate::widgets::font_combo(ui, "fontdlg_font", 220.0, font, &fams, Some(&*prev)) {
+                    *font = f;
+                }
                 ui.end_row();
                 ui.label(tl!("Size:"));
                 ui.text_edit_singleline(size);
                 ui.end_row();
                 ui.label(tl!("Font color:"));
-                ui.text_edit_singleline(color);
+                let theme = app.session.doc.settings.theme_colors.clone();
+                color_field(ui, &theme, color, "Automatic", "auto");
                 ui.end_row();
                 ui.label(tl!("Spacing (pt):"));
                 ui.add(egui::DragValue::new(spacing).speed(0.1).range(-20.0..=20.0));
@@ -1201,22 +1513,7 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             ui.label(job);
             let (ok, cancel) = buttons(ui, tl!("OK"));
             if ok {
-                let mut props = json!({
-                    "bold": *bold, "italic": *italic, "strike": *strike,
-                    "underline": if *underline { "single" } else { "none" },
-                    "vertAlign": if *sup { "superscript" } else if *sub { "subscript" } else { "baseline" },
-                    "smallCaps": *small_caps, "caps": *caps, "hidden": *hidden, "spacing": *spacing,
-                });
-                if !font.trim().is_empty() {
-                    props["font"] = json!(font.trim());
-                }
-                if let Ok(s) = size.trim().parse::<f64>() {
-                    props["size"] = json!(s);
-                }
-                if let Some(c) = wordcraft_doc::Rgb::parse(color) {
-                    props["color"] = json!({"Rgb": [c.0, c.1, c.2]});
-                }
-                let _ = app.run("format.set", json!({"props": props}));
+                apply_font(app, d);
             }
             ok || cancel
         }
@@ -1229,6 +1526,7 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             before,
             after,
             line,
+            line_was,
             keep_next,
             keep_lines,
             page_break,
@@ -1236,6 +1534,8 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             tab,
             asian,
             asian_was,
+            opts,
+            opts_was,
         } => {
             ui.horizontal(|ui| {
                 for (k, name) in ["Indents and Spacing", "Line and Page Breaks", "Asian Typography"].into_iter().enumerate() {
@@ -1264,16 +1564,34 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
                         });
                     });
                     ui.label(egui::RichText::new(tl!("Indentation")).font(semibold(12.5)));
+                    // Mirrored indents are the inside and outside ones (they swap on even pages).
+                    let (l_label, r_label) = if opts[0] { ("Inside:", "Outside:") } else { ("Left:", "Right:") };
                     egui::Grid::new("ind").num_columns(4).show(ui, |ui| {
-                        ui.label(tl!("Left:"));
-                        ui.add(egui::DragValue::new(left).speed(0.05).suffix("\"").max_decimals(2));
-                        ui.label(tl!("Right:"));
-                        ui.add(egui::DragValue::new(right).speed(0.05).suffix("\"").max_decimals(2));
+                        ui.label(tl!(l_label));
+                        ui.add(
+                            egui::DragValue::new(left)
+                                .speed(3.6 / crate::options::unit().pt_per_unit())
+                                .suffix(crate::options::unit().suffix())
+                                .max_decimals(2),
+                        );
+                        ui.label(tl!(r_label));
+                        ui.add(
+                            egui::DragValue::new(right)
+                                .speed(3.6 / crate::options::unit().pt_per_unit())
+                                .suffix(crate::options::unit().suffix())
+                                .max_decimals(2),
+                        );
                         ui.end_row();
                         ui.label(tl!("First line:"));
-                        ui.add(egui::DragValue::new(first).speed(0.05).suffix("\"").max_decimals(2));
+                        ui.add(
+                            egui::DragValue::new(first)
+                                .speed(3.6 / crate::options::unit().pt_per_unit())
+                                .suffix(crate::options::unit().suffix())
+                                .max_decimals(2),
+                        );
                         ui.end_row();
                     });
+                    ui.checkbox(&mut opts[0], tl!("Mirror indents"));
                     ui.label(egui::RichText::new(tl!("Spacing")).font(semibold(12.5)));
                     egui::Grid::new("sp").num_columns(4).show(ui, |ui| {
                         ui.label(tl!("Before:"));
@@ -1285,6 +1603,7 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
                         ui.add(egui::DragValue::new(after).speed(1.0).range(0.0..=1584.0).suffix(format!(" {}", tl!("pt"))));
                         ui.end_row();
                     });
+                    ui.checkbox(&mut opts[1], tl!("Don't add space between paragraphs of the same style"));
                 }
                 1 => {
                     ui.label(egui::RichText::new(tl!("Line and Page Breaks")).font(semibold(12.5)));
@@ -1292,6 +1611,9 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
                     ui.checkbox(keep_next, tl!("Keep with next"));
                     ui.checkbox(keep_lines, tl!("Keep lines together"));
                     ui.checkbox(page_break, tl!("Page break before"));
+                    ui.label(egui::RichText::new(tl!("Formatting exceptions")).font(semibold(12.5)));
+                    ui.checkbox(&mut opts[2], tl!("Suppress line numbers"));
+                    ui.checkbox(&mut opts[3], tl!("Don't hyphenate"));
                 }
                 _ => {
                     let [kinsoku, word_wrap, overflow, top_line, de, dn] = asian;
@@ -1313,7 +1635,19 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             let tabs = ui.button(tl!("Tabs…")).clicked();
             let (ok, cancel) = buttons(ui, tl!("OK"));
             if ok || tabs {
-                apply_paragraph(app, *rtl, align, *left, *right, *first, *before, *after, *line, [*keep_next, *keep_lines, *page_break, *widow]);
+                apply_paragraph(
+                    app,
+                    *rtl,
+                    align,
+                    *left,
+                    *right,
+                    *first,
+                    *before,
+                    *after,
+                    (*line, *line_was),
+                    [*keep_next, *keep_lines, *page_break, *widow],
+                    (*opts, *opts_was),
+                );
                 apply_asian(app, *asian, *asian_was);
             }
             // Tabs… keeps what was set here and moves on to the Tabs dialog.
@@ -1324,7 +1658,7 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
         }
         Dialog::Tabs { form } => crate::dialogs_para::tabs(app, ui, form),
         Dialog::Borders { form } => crate::dialogs_para::borders(app, ui, form),
-        Dialog::Find { query, replace, match_case, whole_word, regex, replace_mode, message } => {
+        Dialog::Find { query, replace, match_case, whole_word, regex, extra, replace_mode, message } => {
             ui.horizontal(|ui| {
                 if ui.selectable_label(!*replace_mode, tl!("Find")).clicked() {
                     *replace_mode = false;
@@ -1335,20 +1669,59 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             });
             ui.horizontal(|ui| {
                 ui.label(tl!("Find what:"));
-                ui.add(egui::TextEdit::singleline(query).desired_width(240.0));
+                if ui.add(egui::TextEdit::singleline(query).desired_width(240.0)).gained_focus() {
+                    extra.to_replace = false;
+                }
             });
             if *replace_mode {
                 ui.horizontal(|ui| {
                     ui.label(tl!("Replace with:"));
-                    ui.add(egui::TextEdit::singleline(replace).desired_width(228.0));
+                    if ui.add(egui::TextEdit::singleline(replace).desired_width(228.0)).gained_focus() {
+                        extra.to_replace = true;
+                    }
+                });
+            } else {
+                extra.to_replace = false;
+            }
+            // Word greys out Match case and the word options with wildcards (they always match case).
+            let plain = !extra.wildcards;
+            ui.horizontal(|ui| {
+                ui.add_enabled(plain, egui::Checkbox::new(match_case, tl!("Match case")));
+                ui.add_enabled(plain, egui::Checkbox::new(whole_word, tl!("Whole words")));
+                ui.checkbox(&mut extra.wildcards, tl!("Use wildcards"));
+            });
+            let arrow = if extra.more { "▾" } else { "▸" };
+            if ui.selectable_label(extra.more, format!("{arrow} {}", tl!("Search Options"))).clicked() {
+                extra.more = !extra.more;
+            }
+            if extra.more {
+                ui.horizontal(|ui| {
+                    ui.add_enabled(plain, egui::Checkbox::new(&mut extra.prefix, tl!("Match prefix")));
+                    ui.add_enabled(plain, egui::Checkbox::new(&mut extra.suffix, tl!("Match suffix")));
+                });
+                ui.horizontal(|ui| {
+                    ui.add_enabled(plain, egui::Checkbox::new(&mut extra.ignore_punct, tl!("Ignore punctuation characters")));
+                    ui.add_enabled(plain, egui::Checkbox::new(&mut extra.ignore_space, tl!("Ignore white-space characters")));
+                });
+                ui.horizontal(|ui| {
+                    ui.checkbox(regex, tl!("Regular expressions"));
+                    if let Some(code) = special_menu(ui, extra) {
+                        if extra.to_replace { replace.push_str(code) } else { query.push_str(code) }
+                    }
                 });
             }
-            ui.horizontal(|ui| {
-                ui.checkbox(match_case, tl!("Match case"));
-                ui.checkbox(whole_word, tl!("Whole words"));
-                ui.checkbox(regex, tl!("Wildcards (regex)"));
+            let opts = json!({
+                "text": query,
+                "with": replace,
+                "matchCase": *match_case,
+                "wholeWord": *whole_word,
+                "regex": *regex,
+                "wildcards": extra.wildcards,
+                "matchPrefix": extra.prefix,
+                "matchSuffix": extra.suffix,
+                "ignorePunct": extra.ignore_punct,
+                "ignoreSpace": extra.ignore_space,
             });
-            let opts = json!({"text": query, "with": replace, "matchCase": *match_case, "wholeWord": *whole_word, "regex": *regex});
             if !*replace_mode {
                 ui.horizontal(|ui| {
                     let lit = app.session.find.highlight;
@@ -1380,8 +1753,8 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
                     }
                 }
                 if ui.button(tl!("Find Next")).clicked() || ui.input(|i| i.key_pressed(egui::Key::Enter)) {
-                    let _ = app.session.run("edit.find", &opts);
-                    match app.run("edit.findNext", json!({})) {
+                    // One step per click: `edit.find` would select a match itself, and the step after it skip one.
+                    match app.run("edit.findNext", opts.clone()) {
                         Ok(r) => *message = format!("Match {} of {}", r["index"].as_u64().unwrap_or(0) + 1, r["count"]),
                         Err(e) => *message = e,
                     }
@@ -1463,14 +1836,34 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             ui.label(egui::RichText::new(tl!("Margins")).font(semibold(12.5)));
             egui::Grid::new("ps").num_columns(4).show(ui, |ui| {
                 ui.label(tl!("Top:"));
-                ui.add(egui::DragValue::new(top).speed(0.05).suffix("\"").max_decimals(2));
+                ui.add(
+                    egui::DragValue::new(top)
+                        .speed(3.6 / crate::options::unit().pt_per_unit())
+                        .suffix(crate::options::unit().suffix())
+                        .max_decimals(2),
+                );
                 ui.label(tl!("Bottom:"));
-                ui.add(egui::DragValue::new(bottom).speed(0.05).suffix("\"").max_decimals(2));
+                ui.add(
+                    egui::DragValue::new(bottom)
+                        .speed(3.6 / crate::options::unit().pt_per_unit())
+                        .suffix(crate::options::unit().suffix())
+                        .max_decimals(2),
+                );
                 ui.end_row();
                 ui.label(tl!("Left:"));
-                ui.add(egui::DragValue::new(left).speed(0.05).suffix("\"").max_decimals(2));
+                ui.add(
+                    egui::DragValue::new(left)
+                        .speed(3.6 / crate::options::unit().pt_per_unit())
+                        .suffix(crate::options::unit().suffix())
+                        .max_decimals(2),
+                );
                 ui.label(tl!("Right:"));
-                ui.add(egui::DragValue::new(right).speed(0.05).suffix("\"").max_decimals(2));
+                ui.add(
+                    egui::DragValue::new(right)
+                        .speed(3.6 / crate::options::unit().pt_per_unit())
+                        .suffix(crate::options::unit().suffix())
+                        .max_decimals(2),
+                );
                 ui.end_row();
             });
             ui.label(egui::RichText::new(tl!("Orientation")).font(semibold(12.5)));
@@ -1501,7 +1894,7 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             if ok {
                 let _ = app.run("layout.orientation", json!({"value": if *landscape { "landscape" } else { "portrait" }}));
                 let _ =
-                    app.run("layout.margins", json!({"top": *top * 72.0, "bottom": *bottom * 72.0, "left": *left * 72.0, "right": *right * 72.0}));
+                    app.run("layout.margins", json!({"top": *top * crate::options::unit().pt_per_unit(), "bottom": *bottom * crate::options::unit().pt_per_unit(), "left": *left * crate::options::unit().pt_per_unit(), "right": *right * crate::options::unit().pt_per_unit()}));
                 if grid != grid_was {
                     let kind = ["none", "lines", "linesAndChars", "snapToChars"].get(grid.0 as usize).copied().unwrap_or("none");
                     let mut v = json!({"type": kind});
@@ -1687,7 +2080,7 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             }
             ok || cancel
         }
-        Dialog::ModifyStyle { back, id, name, font, size, bold, italic, color, before, after } => {
+        Dialog::ModifyStyle { back, resume, id, name, font, size, bold, italic, color, before, after } => {
             egui::Grid::new("ms").num_columns(2).show(ui, |ui| {
                 ui.label(tl!("Name:"));
                 ui.text_edit_singleline(name);
@@ -1724,6 +2117,11 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             if (ok || cancel) && *back {
                 app.dialog = Some(Dialog::ManageStyles { alphabetical: false, selected: id.clone() });
             }
+            if (ok || cancel)
+                && let Some(r) = resume.take()
+            {
+                app.dialog = Some(*r);
+            }
             ok || cancel
         }
         Dialog::ManageStyles { alphabetical, selected } => manage_styles(app, ui, alphabetical, selected),
@@ -1819,6 +2217,7 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             ok || cancel
         }
         Dialog::Insert(f) => crate::dialogs_insert::body(app, ui, f),
+        Dialog::Refs(f) => crate::dialogs_refs::body(app, ui, f),
         Dialog::Commands { query } => {
             let r = ui.add(egui::TextEdit::singleline(query).hint_text(tl!("Type a command, e.g. \"insert table\"")).desired_width(380.0));
             r.request_focus();
@@ -2053,6 +2452,7 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
         }
         Dialog::DefineList { form } => crate::dialogs_lists::define_list(app, ui, form),
         Dialog::TrackOptions { form } => crate::dialogs_lists::track_options(app, ui, form),
+        Dialog::Review(d) => crate::dialogs_review::body(app, ui, d),
         Dialog::CustomizeKeyboard { form } => crate::dialogs_keyboard::customize_keyboard(app, ui, form),
         Dialog::CustomizeRibbon { form } => crate::dialogs_ribbon::customize_ribbon(app, ui, form),
         Dialog::FieldCode { code, edit, message } => {
@@ -2079,6 +2479,7 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             }
             cancel
         }
+        Dialog::Control { form } => crate::dialogs_controls::body(app, ui, form),
         Dialog::SelectTable { sheets, selected, headers, message, params } => {
             ui.label(tl!("Choose the sheet that holds the recipients."));
             ui.add_space(4.0);
@@ -2115,6 +2516,9 @@ fn body(app: &mut WordApp, ui: &mut Ui, d: &mut Dialog) -> bool {
             cancel
         }
         Dialog::NoteOptions { form } => crate::dialogs_notes::note_options(app, ui, form),
+        Dialog::Templates { form } => crate::dialogs_templates::templates(app, ui, form),
+        Dialog::Organizer { form } => crate::dialogs_templates::organizer(app, ui, form),
+        Dialog::Layout(d) => crate::dialogs_layout::body(app, ui, d),
         Dialog::FindRecipient { text, message } => {
             ui.horizontal(|ui| {
                 ui.label(tl!("Find:"));
@@ -2299,12 +2703,9 @@ fn recipient_list(app: &mut WordApp, ui: &mut Ui, fields: &mut Vec<String>, rows
     }
 }
 
-/// The Paragraph dialog's OK. `align`, `left` and `right` are as seen on the page; `flags` are
-/// keep with next, keep lines together, page break before, widow/orphan control.
-#[allow(clippy::too_many_arguments)]
 /// The Table Properties dialog's fields: Table, Row, Column and Cell sections.
 fn table_properties(ui: &mut Ui, f: &mut TableForm) {
-    let unit = wordcraft_geom::Unit::default();
+    let unit = crate::options::unit();
     fn len(v: &mut f32, lo: f32, unit: wordcraft_geom::Unit) -> egui::DragValue<'_> {
         egui::DragValue::new(v).speed(0.01).range(lo..=22.0).suffix(unit.suffix()).max_decimals(2)
     }
@@ -2371,6 +2772,11 @@ fn table_properties(ui: &mut Ui, f: &mut TableForm) {
     });
 }
 
+/// The Paragraph dialog's OK. `align`, `left` and `right` are as seen on the page; `flags` are
+/// keep with next, keep lines together, page break before, widow/orphan control; `opts` (now,
+/// when opened) are mirror indents, contextual spacing, suppress line numbers and don't
+/// hyphenate, of which only the changed ones are set.
+#[allow(clippy::too_many_arguments)]
 fn apply_paragraph(
     app: &mut WordApp,
     rtl: bool,
@@ -2380,23 +2786,38 @@ fn apply_paragraph(
     first: f32,
     before: f32,
     after: f32,
-    line: f32,
+    line: (f32, f32),
     flags: [bool; 4],
+    opts: ([bool; 4], [bool; 4]),
 ) {
     let [keep_next, keep_lines, page_break, widow] = flags;
+    let (line, line_was) = line;
     // Direction first: the alignment and indents are as seen on the page, and their logical
     // values depend on it.
     let _ = app.run(if rtl { "para.rtl" } else { "para.ltr" }, json!({}));
     let _ = app.run("para.align", json!({"value": align}));
     let (start, end) = if rtl { (right, left) } else { (left, right) };
-    let _ = app.run(
-        "para.set",
-        json!({"props": {
-            "indentLeft": start * 72.0, "indentRight": end * 72.0, "indentFirst": first * 72.0,
-            "spaceBefore": before, "spaceAfter": after, "lineSpacing": {"rule": "multiple", "value": line},
-            "keepNext": keep_next, "keepLines": keep_lines, "pageBreakBefore": page_break, "widowControl": widow,
-        }}),
-    );
+    let mut props = json!({
+        "indentLeft": start * crate::options::unit().pt_per_unit(), "indentRight": end * crate::options::unit().pt_per_unit(), "indentFirst": first * crate::options::unit().pt_per_unit(),
+        "spaceBefore": before, "spaceAfter": after,
+        "keepNext": keep_next, "keepLines": keep_lines, "pageBreakBefore": page_break, "widowControl": widow,
+    });
+    // The dialog edits only multiples: an untouched value keeps Exactly and At Least.
+    if line != line_was
+        && let Some(m) = props.as_object_mut()
+    {
+        m.insert("lineSpacing".into(), json!({"rule": "multiple", "value": line}));
+    }
+    let (now, was) = opts;
+    for (key, (on, was)) in ["mirrorIndents", "contextualSpacing", "suppressLineNumbers", "suppressHyphens"].into_iter().zip(now.into_iter().zip(was))
+    {
+        if on != was
+            && let Some(m) = props.as_object_mut()
+        {
+            m.insert(key.into(), json!(on));
+        }
+    }
+    let _ = app.run("para.set", json!({ "props": props }));
 }
 
 /// The Paragraph dialog's Asian Typography: sets the flags that changed since it opened, so an
@@ -2461,7 +2882,7 @@ fn manage_styles(app: &mut WordApp, ui: &mut Ui, alphabetical: &mut bool, select
                     if let Some(Dialog::ModifyStyle { id, name, font, size, bold, italic, color, before, after, .. }) =
                         Dialog::modify_style(app, selected)
                     {
-                        app.dialog = Some(Dialog::ModifyStyle { back: true, id, name, font, size, bold, italic, color, before, after });
+                        app.dialog = Some(Dialog::ModifyStyle { back: true, resume: None, id, name, font, size, bold, italic, color, before, after });
                     }
                 }
             }
@@ -2498,7 +2919,7 @@ fn manage_styles(app: &mut WordApp, ui: &mut Ui, alphabetical: &mut bool, select
         if ui.add_enabled(ty != "table", egui::Button::new(tl!("Modify…"))).clicked()
             && let Some(Dialog::ModifyStyle { id, name, font, size, bold, italic, color, before, after, .. }) = Dialog::modify_style(app, selected)
         {
-            app.dialog = Some(Dialog::ModifyStyle { back: true, id, name, font, size, bold, italic, color, before, after });
+            app.dialog = Some(Dialog::ModifyStyle { back: true, resume: None, id, name, font, size, bold, italic, color, before, after });
         }
         if ui.button(tl!("New Style…")).clicked() {
             app.dialog = Some(Dialog::NewStyle { name: "Style1".into(), based_on: str_of(&cur, "name"), back: true });
@@ -2676,6 +3097,7 @@ fn enclose_preview(ui: &mut Ui, style: &str, text: &str, shape: &str) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use wordcraft_doc::Pos;
     use wordcraft_doc::props::Align;
     use wordcraft_engine::Session;
 
@@ -2738,12 +3160,66 @@ mod tests {
 
     /// Open the Paragraph dialog and press OK without changing anything.
     fn ok_unchanged(app: &mut WordApp) {
-        let Some(Dialog::Paragraph { rtl, align, left, right, first, before, after, line, keep_next, keep_lines, page_break, widow, .. }) =
-            Dialog::open("paragraph", app)
+        ok_with(app, |_| {});
+    }
+
+    /// Open the Paragraph dialog, change its options (`opts`) with `edit` and press OK.
+    fn ok_with(app: &mut WordApp, edit: impl FnOnce(&mut [bool; 4])) {
+        let Some(Dialog::Paragraph {
+            rtl,
+            align,
+            left,
+            right,
+            first,
+            before,
+            after,
+            line,
+            line_was,
+            keep_next,
+            keep_lines,
+            page_break,
+            widow,
+            mut opts,
+            ..
+        }) = Dialog::open("paragraph", app)
         else {
             panic!("no paragraph dialog")
         };
-        apply_paragraph(app, rtl, &align, left, right, first, before, after, line, [keep_next, keep_lines, page_break, widow]);
+        let was = opts;
+        edit(&mut opts);
+        apply_paragraph(
+            app,
+            rtl,
+            &align,
+            left,
+            right,
+            first,
+            before,
+            after,
+            (line, line_was),
+            [keep_next, keep_lines, page_break, widow],
+            (opts, was),
+        );
+    }
+
+    #[test]
+    fn paragraph_dialog_sets_only_the_options_that_changed() {
+        // #512: mirror indents, same-style spacing, suppress line numbers, don't hyphenate.
+        let mut app = app_with("Hello");
+        ok_unchanged(&mut app);
+        let p = props(&app);
+        assert_eq!((p.mirror_indents, p.contextual_spacing, p.suppress_line_numbers, p.suppress_hyphens), (None, None, None, None));
+        ok_with(&mut app, |o| *o = [true; 4]);
+        let p = props(&app);
+        assert_eq!(
+            (p.mirror_indents, p.contextual_spacing, p.suppress_line_numbers, p.suppress_hyphens),
+            (Some(true), Some(true), Some(true), Some(true))
+        );
+        let Some(Dialog::Paragraph { opts, .. }) = Dialog::open("paragraph", &mut app) else { panic!() };
+        assert_eq!(opts, [true; 4], "the dialog shows what is set");
+        ok_with(&mut app, |o| o[3] = false);
+        assert_eq!(props(&app).suppress_hyphens, Some(false));
+        assert_eq!(props(&app).mirror_indents, Some(true));
     }
 
     #[test]
@@ -2772,16 +3248,111 @@ mod tests {
         }
     }
 
+    #[test]
+    fn paragraph_dialog_keeps_fixed_line_spacing() {
+        use wordcraft_doc::props::LineSpacing;
+        for (cmd, rule) in [(json!({"exactly": 24}), LineSpacing::Exactly(24.0)), (json!({"atLeast": 24}), LineSpacing::AtLeast(24.0))] {
+            // OK without changes, and OK after changing only Keep with next (#467).
+            let mut app = app_with("Example");
+            let _ = app.run("para.lineSpacing", cmd.clone());
+            ok_unchanged(&mut app);
+            assert_eq!(props(&app).line_spacing, Some(rule), "unchanged OK, {cmd}");
+            let Some(Dialog::Paragraph { rtl, align, left, right, first, before, after, line, line_was, keep_lines, page_break, widow, .. }) =
+                Dialog::open("paragraph", &mut app)
+            else {
+                panic!("no paragraph dialog")
+            };
+            apply_paragraph(
+                &mut app,
+                rtl,
+                &align,
+                left,
+                right,
+                first,
+                before,
+                after,
+                (line, line_was),
+                [true, keep_lines, page_break, widow],
+                ([false; 4], [false; 4]),
+            );
+            let p = props(&app);
+            assert_eq!((p.line_spacing, p.keep_next), (Some(rule), Some(true)), "Keep with next, {cmd}");
+        }
+        // A changed value still sets a multiple.
+        let mut app = app_with("Example");
+        let _ = app.run("para.lineSpacing", json!({"exactly": 24}));
+        let Some(Dialog::Paragraph { rtl, align, left, right, first, before, after, line_was, keep_next, keep_lines, page_break, widow, .. }) =
+            Dialog::open("paragraph", &mut app)
+        else {
+            panic!("no paragraph dialog")
+        };
+        apply_paragraph(
+            &mut app,
+            rtl,
+            &align,
+            left,
+            right,
+            first,
+            before,
+            after,
+            (1.5, line_was),
+            [keep_next, keep_lines, page_break, widow],
+            ([false; 4], [false; 4]),
+        );
+        assert_eq!(props(&app).line_spacing, Some(LineSpacing::Multiple(1.5)));
+    }
+
+    #[test]
+    fn font_dialog_sets_the_asian_and_latin_fonts_separately() {
+        // #505: the Asian text font box and the Latin text font box each set their own font, and
+        // OK leaves the one not changed as it was.
+        let mut app = app_with("Hello 你好");
+        let _ = app.run("select.all", json!({}));
+        let fonts = |app: &WordApp| {
+            let c = app.session.doc.para_at(&Pos::body(0, 0)).map(|p| p.props_of_char(0).clone()).unwrap_or_default();
+            (c.font, c.font_ea)
+        };
+        let latin = fonts(&app).0;
+        let Some(mut d) = Dialog::open("font", &mut app) else { panic!("no font dialog") };
+        let Dialog::Font { asian, font_ea, .. } = &mut d else { panic!() };
+        assert!(*asian, "Chinese text in the selection shows the Asian text font box");
+        *font_ea = "SimSun".into();
+        apply_font(&mut app, &d);
+        assert_eq!(fonts(&app), (latin, Some("SimSun".into())));
+        let Some(mut d) = Dialog::open("font", &mut app) else { panic!() };
+        let Dialog::Font { font, font_ea, .. } = &mut d else { panic!() };
+        assert_eq!(font_ea, "SimSun");
+        *font = "Georgia".into();
+        apply_font(&mut app, &d);
+        assert_eq!(fonts(&app), (Some("Georgia".into()), Some("SimSun".into())));
+        // One undo step each.
+        let _ = app.run("edit.undo", json!({}));
+        assert_eq!(fonts(&app).1.as_deref(), Some("SimSun"));
+        assert_ne!(fonts(&app).0.as_deref(), Some("Georgia"));
+    }
+
     #[test]
     fn paragraph_dialog_changes_direction() {
         let mut app = app_with("Hello");
-        let Some(Dialog::Paragraph { align, left, right, first, before, after, line, keep_next, keep_lines, page_break, widow, .. }) =
+        let Some(Dialog::Paragraph { align, left, right, first, before, after, line, line_was, keep_next, keep_lines, page_break, widow, .. }) =
             Dialog::open("paragraph", &mut app)
         else {
             panic!()
         };
         // Right to left, aligned right on the page, 1" from the right edge.
-        apply_paragraph(&mut app, true, "right", left, right + 1.0, first, before, after, line, [keep_next, keep_lines, page_break, widow]);
+        apply_paragraph(
+            &mut app,
+            true,
+            "right",
+            left,
+            right + 1.0,
+            first,
+            before,
+            after,
+            (line, line_was),
+            [keep_next, keep_lines, page_break, widow],
+            ([false; 4], [false; 4]),
+        );
         let _ = align;
         let p = props(&app);
         assert_eq!(p.bidi, Some(true));
@@ -2821,4 +3392,71 @@ mod tests {
             assert!((t - tops[0]).abs() <= 0.5, "the tab strip stays put: {tops:?}");
         }
     }
+
+    #[test]
+    fn font_dialog_ok_keeps_what_the_user_left_alone() {
+        // Issue #466: OK sent every field, clearing small caps, spacing and double underline
+        // when only the size changed.
+        let mut app = app_with("Example");
+        let _ = app.run("select.all", json!({}));
+        let _ = app.run("format.set", json!({"props": {"smallCaps": true, "caps": true, "hidden": true, "spacing": 2, "underline": "double"}}));
+        let Some(mut d) = Dialog::open("font", &mut app) else { panic!("no font dialog") };
+        if let Dialog::Font { size, small_caps, spacing, .. } = &mut d {
+            assert!(*small_caps, "the dialog shows small caps");
+            assert_eq!(*spacing, 2.0);
+            *size = "14".into();
+        }
+        apply_font(&mut app, &d);
+        let c = app.session.doc.para_at(&wordcraft_doc::Pos::body(0, 0)).map(|p| p.props_of_char(0).clone()).unwrap_or_default();
+        assert_eq!(c.size, Some(14.0));
+        assert_eq!((c.small_caps, c.caps, c.hidden, c.spacing), (Some(true), Some(true), Some(true), Some(2.0)));
+        assert_eq!(c.underline, Some(wordcraft_doc::props::Underline::Double));
+        // A field the user does change still applies.
+        let Some(mut d) = Dialog::open("font", &mut app) else { panic!("no font dialog") };
+        if let Dialog::Font { small_caps, .. } = &mut d {
+            *small_caps = false;
+        }
+        apply_font(&mut app, &d);
+        let c = app.session.doc.para_at(&wordcraft_doc::Pos::body(0, 0)).map(|p| p.props_of_char(0).clone()).unwrap_or_default();
+        assert_eq!((c.small_caps, c.caps, c.size), (Some(false), Some(true), Some(14.0)));
+    }
+
+    /// A dialog was pinned by its anchor, so dragging its title bar did nothing (#732).
+    #[test]
+    fn dragging_a_dialog_title_bar_moves_it() {
+        let mut app = app_with("Some text");
+        app.dialog = Dialog::open("paragraph", &mut app);
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
+            |ui, app: &mut WordApp| {
+                let ctx = ui.ctx().clone();
+                app.logic(&ctx);
+                app.ui(ui);
+            },
+            app,
+        );
+        for _ in 0..4 {
+            h.step();
+        }
+        let id = egui::Id::new(("dialog", "Paragraph"));
+        let before = h.ctx.memory(|m| m.area_rect(id)).expect("dialog is open");
+        let screen = h.ctx.content_rect();
+        assert!((before.center().x - screen.center().x).abs() <= 1.0, "opens centred: {before:?} in {screen:?}");
+        let grab = egui::pos2(before.center().x, before.top() + 10.0);
+        let drop = grab + vec2(-200.0, 120.0);
+        let button =
+            |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE };
+        h.event(egui::Event::PointerMoved(grab));
+        h.step();
+        h.event(button(grab, true));
+        h.step();
+        h.event(egui::Event::PointerMoved(drop));
+        h.step();
+        h.event(button(drop, false));
+        for _ in 0..4 {
+            h.step();
+        }
+        let after = h.ctx.memory(|m| m.area_rect(id)).expect("dialog is still open");
+        assert!((after.min.x - (before.min.x - 200.0)).abs() <= 1.0, "moved left: {before:?} -> {after:?}");
+        assert!((after.min.y - (before.min.y + 120.0)).abs() <= 1.0, "moved down: {before:?} -> {after:?}");
+    }
 }
diff --git a/crates/ui-egui/src/dialogs_chart.rs b/crates/ui-egui/src/dialogs_chart.rs
new file mode 100644
index 0000000000..72663acb7a
--- /dev/null
+++ b/crates/ui-egui/src/dialogs_chart.rs
@@ -0,0 +1,359 @@
+//! Insert Chart / Change Chart Type (a gallery of chart types with previews drawn in code) and
+//! Edit Data (the chart's categories and series in an editable grid). Each ends by running one
+//! command (`insert.chart`, `chart.type`, `chart.editData`), so agents get the same result
+//! without the dialog. Shown through [`crate::dialogs_insert::InsertDialog`].
+
+use egui::{Color32, Pos2, Rect, Sense, Shape, Stroke, Ui, pos2, vec2};
+use serde::Serialize;
+use serde_json::{Value, json};
+use wordcraft_doc::chart::{ChartSpec, ChartType, MAX_POINTS, MAX_SERIES};
+
+use crate::WordApp;
+use crate::theme::{Tokens, c32};
+
+/// Insert › Chart (`change` false) or Chart Design › Change Chart Type (`change` true).
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ChartTypeForm {
+    #[serde(rename = "type")]
+    pub kind: ChartType,
+    pub change: bool,
+}
+
+impl ChartTypeForm {
+    pub fn new(app: &WordApp, change: bool) -> Option<ChartTypeForm> {
+        let current = wordcraft_engine::cmd::chart::selected_chart(&app.session);
+        if change && current.is_none() {
+            return None;
+        }
+        Some(ChartTypeForm { kind: current.map(|c| c.kind).unwrap_or_default(), change })
+    }
+}
+
+/// Chart Design › Edit Data: the grid as text, a row per category and a column per series.
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ChartDataForm {
+    pub categories: Vec<String>,
+    pub names: Vec<String>,
+    /// `cells[row][series]`.
+    pub cells: Vec<Vec<String>>,
+    pub message: String,
+}
+
+impl ChartDataForm {
+    pub fn new(app: &WordApp) -> Option<ChartDataForm> {
+        let c = wordcraft_engine::cmd::chart::selected_chart(&app.session)?;
+        Some(Self::of(&c))
+    }
+
+    pub fn of(c: &ChartSpec) -> ChartDataForm {
+        let cells = (0..c.points())
+            .map(|i| c.series.iter().map(|s| s.values.get(i).copied().flatten().map(|v| format!("{v}")).unwrap_or_default()).collect())
+            .collect();
+        ChartDataForm { categories: c.categories.clone(), names: c.series.iter().map(|s| s.name.clone()).collect(), cells, message: String::new() }
+    }
+
+    /// The `chart.editData` params, or the first cell that isn't a number.
+    pub fn params(&self) -> Result<Value, String> {
+        let mut series = Vec::new();
+        for (j, name) in self.names.iter().enumerate() {
+            let mut values = Vec::new();
+            for (i, row) in self.cells.iter().enumerate() {
+                let t = row.get(j).map(|t| t.trim()).unwrap_or("");
+                if t.is_empty() {
+                    values.push(Value::Null);
+                    continue;
+                }
+                // A decimal comma is read as a point.
+                match t.parse::<f64>().or_else(|_| t.replace(',', ".").parse::<f64>()).ok().filter(|v| v.is_finite()) {
+                    Some(v) => values.push(json!(v)),
+                    None => {
+                        let at = self.categories.get(i).filter(|c| !c.is_empty()).cloned().unwrap_or_else(|| (i + 1).to_string());
+                        return Err(crate::i18n::fmt(
+                            tl!("“{text}” ({row}, {series}) isn't a number."),
+                            &[("text", t), ("row", &at), ("series", name)],
+                        ));
+                    }
+                }
+            }
+            series.push(json!({"name": name, "values": values}));
+        }
+        Ok(json!({"data": {"categories": self.categories, "series": series}}))
+    }
+
+    fn add_row(&mut self) {
+        if self.categories.len() < MAX_POINTS {
+            self.categories.push(crate::i18n::fmt(tl!("Category {n}"), &[("n", &(self.categories.len() + 1).to_string())]));
+            self.cells.push(vec![String::new(); self.names.len()]);
+        }
+    }
+
+    fn add_series(&mut self) {
+        if self.names.len() < MAX_SERIES {
+            self.names.push(crate::i18n::fmt(tl!("Series {n}"), &[("n", &(self.names.len() + 1).to_string())]));
+            for r in &mut self.cells {
+                r.push(String::new());
+            }
+        }
+    }
+}
+
+/// The theme's first accents, for previews.
+fn accents(app: &WordApp) -> [Color32; 3] {
+    let t = &app.session.doc.settings.theme_colors;
+    let at = |i: usize, d: Color32| t.get(i).map(|c| c32(*c)).unwrap_or(d);
+    [at(4, Color32::from_rgb(0x15, 0x60, 0x82)), at(5, Color32::from_rgb(0xE9, 0x71, 0x32)), at(6, Color32::from_rgb(0x19, 0x6B, 0x24))]
+}
+
+/// A small picture of a chart type in `r`, in the accents `col` with axis lines in `line`.
+pub fn preview(p: &egui::Painter, r: Rect, kind: ChartType, col: [Color32; 3], line: Color32) {
+    let r = r.shrink(r.width().min(r.height()) * 0.12);
+    let at = |x: f32, y: f32| pos2(r.left() + x * r.width(), r.top() + y * r.height());
+    let bar = |x0: f32, y0: f32, x1: f32, y1: f32, c: Color32| p.rect_filled(Rect::from_min_max(at(x0, y0), at(x1, y1)), 0.0, c);
+    let axis = Stroke::new(1.0, line);
+    let data: [[f32; 4]; 3] = [[0.45, 0.6, 0.5, 0.8], [0.3, 0.4, 0.65, 0.5], [0.2, 0.3, 0.35, 0.6]];
+    match kind {
+        ChartType::Column | ChartType::ColumnStacked | ChartType::Bar | ChartType::BarStacked => {
+            let stacked = matches!(kind, ChartType::ColumnStacked | ChartType::BarStacked);
+            let horizontal = matches!(kind, ChartType::Bar | ChartType::BarStacked);
+            for i in 0..3 {
+                let band = (i as f32) / 3.0;
+                let mut base = 0.0;
+                for (j, c) in col.iter().enumerate() {
+                    let v = data.get(j).and_then(|d| d.get(i)).copied().unwrap_or(0.5) * if stacked { 0.4 } else { 1.0 };
+                    let (a0, a1) =
+                        if stacked { (band + 0.06, band + 0.27) } else { (band + 0.04 + j as f32 * 0.085, band + 0.04 + (j + 1) as f32 * 0.085) };
+                    if horizontal {
+                        bar(base, 1.0 - a1, base + v, 1.0 - a0, *c);
+                    } else {
+                        bar(a0, 1.0 - base - v, a1, 1.0 - base, *c);
+                    }
+                    if stacked {
+                        base += v;
+                    }
+                }
+            }
+            if horizontal {
+                p.line_segment([at(0.0, 0.0), at(0.0, 1.0)], axis);
+            } else {
+                p.line_segment([at(0.0, 1.0), at(1.0, 1.0)], axis);
+            }
+        }
+        ChartType::Line | ChartType::Area => {
+            for (j, c) in col.iter().enumerate().take(2) {
+                let Some(d) = data.get(j) else { continue };
+                let pts: Vec<Pos2> = d.iter().enumerate().map(|(i, v)| at(i as f32 / 3.0, 1.0 - v)).collect();
+                if kind == ChartType::Area {
+                    // Convex strips between neighbouring points.
+                    for w in pts.windows(2) {
+                        if let [a, b] = w {
+                            p.add(Shape::convex_polygon(vec![*a, *b, pos2(b.x, r.bottom()), pos2(a.x, r.bottom())], *c, Stroke::NONE));
+                        }
+                    }
+                } else {
+                    p.add(Shape::line(pts, Stroke::new(2.0, *c)));
+                }
+            }
+            p.line_segment([at(0.0, 1.0), at(1.0, 1.0)], axis);
+        }
+        ChartType::Pie | ChartType::Doughnut => {
+            let c = r.center();
+            let rad = r.width().min(r.height()) / 2.0;
+            let shares = [0.42, 0.33, 0.25];
+            let mut a = -std::f32::consts::FRAC_PI_2;
+            for (k, share) in shares.iter().enumerate() {
+                let b = a + share * std::f32::consts::TAU;
+                let steps = 12;
+                let mut pts = vec![c];
+                for s in 0..=steps {
+                    let t = a + (b - a) * s as f32 / steps as f32;
+                    pts.push(c + vec2(t.cos(), t.sin()) * rad);
+                }
+                // Each slice is under half a turn, so its fan is convex.
+                p.add(Shape::convex_polygon(pts, col.get(k).copied().unwrap_or(line), Stroke::NONE));
+                a = b;
+            }
+            if kind == ChartType::Doughnut {
+                p.circle_filled(c, rad * 0.5, Tokens::get(p.ctx()).input);
+            }
+        }
+        ChartType::Scatter => {
+            for (j, c) in col.iter().enumerate().take(2) {
+                for i in 0..5 {
+                    let x = 0.08 + i as f32 * 0.2;
+                    let y = 0.85 - (i as f32 * 0.15) - j as f32 * 0.2 + if i % 2 == 0 { 0.05 } else { -0.05 };
+                    p.circle_filled(at(x, y.clamp(0.05, 0.95)), 2.5, *c);
+                }
+            }
+            p.line_segment([at(0.0, 1.0), at(1.0, 1.0)], axis);
+            p.line_segment([at(0.0, 0.0), at(0.0, 1.0)], axis);
+        }
+    }
+}
+
+/// The chart type gallery; returns true to close.
+pub fn type_ui(app: &mut WordApp, ui: &mut Ui, f: &mut ChartTypeForm) -> bool {
+    let t = Tokens::get(ui.ctx());
+    let col = accents(app);
+    let mut chosen = None;
+    egui::Grid::new("chart_types").spacing(vec2(8.0, 8.0)).show(ui, |ui| {
+        for (k, kind) in ChartType::ALL.into_iter().enumerate() {
+            let (rect, resp) = ui.allocate_exact_size(vec2(112.0, 92.0), Sense::click());
+            let on = f.kind == kind;
+            ui.painter().rect(
+                rect,
+                4.0,
+                if on {
+                    t.checked
+                } else if resp.hovered() {
+                    t.hover
+                } else {
+                    t.input
+                },
+                Stroke::new(1.0, if on { t.accent } else { t.border }),
+                egui::StrokeKind::Inside,
+            );
+            let pic = Rect::from_min_size(rect.min + vec2(18.0, 6.0), vec2(76.0, 60.0));
+            preview(ui.painter(), pic, kind, col, t.text_dim);
+            ui.painter().text(
+                pos2(rect.center().x, rect.bottom() - 13.0),
+                egui::Align2::CENTER_CENTER,
+                tl!(kind.label()),
+                crate::theme::regular(11.0),
+                t.text,
+            );
+            let resp = resp.on_hover_text(tl!(kind.label()));
+            if resp.clicked() {
+                f.kind = kind;
+            }
+            if resp.double_clicked() {
+                chosen = Some(kind);
+            }
+            if k % 3 == 2 {
+                ui.end_row();
+            }
+        }
+    });
+    let (ok, cancel) = crate::dialogs::buttons(ui, tl!("OK"));
+    let Some(kind) = chosen.or(ok.then_some(f.kind)) else { return cancel };
+    let r = if f.change { app.run("chart.type", json!({"type": kind.id()})) } else { app.run("insert.chart", json!({"type": kind.id()})) };
+    r.is_ok() || cancel
+}
+
+/// The Edit Data grid; returns true to close.
+pub fn data_ui(app: &mut WordApp, ui: &mut Ui, f: &mut ChartDataForm) -> bool {
+    const CELL_W: f32 = 96.0;
+    const ROW_H: f32 = 24.0;
+    const X_W: f32 = 22.0;
+    let gap = ui.spacing().item_spacing.x;
+    let table_w = (f.names.len() as f32 + 1.0) * (CELL_W + X_W + 2.0 * gap) + 16.0;
+    ui.set_min_width(table_w.clamp(360.0, 760.0));
+    ui.label(tl!("Type the categories down the side and a column of values per series."));
+    ui.add_space(6.0);
+    let mut remove_series = None;
+    let mut remove_row = None;
+    let (can_remove_series, can_remove_row) = (f.names.len() > 1, f.categories.len() > 1);
+    egui::ScrollArea::horizontal().id_salt("chart_data_h").max_width(760.0).show(ui, |ui| {
+        ui.vertical(|ui| {
+            ui.horizontal(|ui| {
+                ui.add_sized([CELL_W, ROW_H - 4.0], egui::Label::new(egui::RichText::new(tl!("Categories")).strong()));
+                ui.allocate_exact_size(vec2(X_W, ROW_H - 4.0), Sense::hover());
+                for (j, n) in f.names.iter_mut().enumerate() {
+                    ui.add_sized([CELL_W, ROW_H - 4.0], egui::TextEdit::singleline(n).hint_text(tl!("Series name")));
+                    let x = ui
+                        .add_enabled_ui(can_remove_series, |ui| ui.add_sized([X_W, ROW_H - 4.0], egui::Button::new("×")))
+                        .inner
+                        .on_hover_text(tl!("Remove series"));
+                    if x.clicked() {
+                        remove_series = Some(j);
+                    }
+                }
+            });
+            ui.separator();
+            let rows = f.categories.len();
+            egui::ScrollArea::vertical().id_salt("chart_data_v").max_height(280.0).show_rows(ui, ROW_H, rows, |ui, range| {
+                for i in range {
+                    ui.horizontal(|ui| {
+                        if let Some(c) = f.categories.get_mut(i) {
+                            ui.add_sized([CELL_W, ROW_H - 4.0], egui::TextEdit::singleline(c));
+                        }
+                        let x = ui
+                            .add_enabled_ui(can_remove_row, |ui| ui.add_sized([X_W, ROW_H - 4.0], egui::Button::new("×")))
+                            .inner
+                            .on_hover_text(tl!("Remove row"));
+                        if x.clicked() {
+                            remove_row = Some(i);
+                        }
+                        if let Some(row) = f.cells.get_mut(i) {
+                            for cell in row.iter_mut() {
+                                ui.add_sized([CELL_W, ROW_H - 4.0], egui::TextEdit::singleline(cell).horizontal_align(egui::Align::Max));
+                                ui.allocate_exact_size(vec2(X_W, ROW_H - 4.0), Sense::hover());
+                            }
+                        }
+                    });
+                }
+            });
+        });
+    });
+    if let Some(j) = remove_series.filter(|_| f.names.len() > 1) {
+        if j < f.names.len() {
+            f.names.remove(j);
+        }
+        for r in &mut f.cells {
+            if j < r.len() {
+                r.remove(j);
+            }
+        }
+    }
+    if let Some(i) = remove_row.filter(|i| *i < f.categories.len() && f.categories.len() > 1) {
+        f.categories.remove(i);
+        if i < f.cells.len() {
+            f.cells.remove(i);
+        }
+    }
+    ui.horizontal(|ui| {
+        if ui.add_enabled(f.categories.len() < MAX_POINTS, egui::Button::new(tl!("Add Row"))).clicked() {
+            f.add_row();
+        }
+        if ui.add_enabled(f.names.len() < MAX_SERIES, egui::Button::new(tl!("Add Series"))).clicked() {
+            f.add_series();
+        }
+    });
+    if !f.message.is_empty() {
+        ui.label(egui::RichText::new(f.message.as_str()).color(Tokens::get(ui.ctx()).red));
+    }
+    let (ok, cancel) = crate::dialogs::buttons(ui, tl!("OK"));
+    if !ok {
+        return cancel;
+    }
+    match f.params().and_then(|p| app.run("chart.editData", p)) {
+        Ok(_) => true,
+        Err(e) => {
+            f.message = e;
+            false
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn data_grid_round_trips_the_chart() {
+        let c = ChartSpec::sample(ChartType::Column);
+        let mut f = ChartDataForm::of(&c);
+        let p = f.params().unwrap();
+        assert_eq!(p["data"]["categories"][3], "Q4");
+        assert_eq!(p["data"]["series"][1]["values"][2], 3.9);
+        f.add_series();
+        f.add_row();
+        f.cells[0][3] = "1,5".into();
+        let p = f.params().unwrap();
+        assert_eq!(p["data"]["series"][3]["values"][0], 1.5);
+        assert!(p["data"]["series"][3]["values"][1].is_null());
+        f.cells[1][0] = "abc".into();
+        assert!(f.params().is_err());
+    }
+}
diff --git a/crates/ui-egui/src/dialogs_controls.rs b/crates/ui-egui/src/dialogs_controls.rs
new file mode 100644
index 0000000000..9bdc1971b9
--- /dev/null
+++ b/crates/ui-egui/src/dialogs_controls.rs
@@ -0,0 +1,206 @@
+//! Developer › Controls › Properties: a content control's title, tag, locks and, by kind, its
+//! list entries, date format or check box symbols. OK runs `developer.properties` with the
+//! settings, so scripts and agents get the same result without the dialog.
+
+use egui::Ui;
+use serde::Serialize;
+use serde_json::{Value, json};
+
+use crate::WordApp;
+use crate::theme::semibold;
+
+/// One list entry being edited.
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct Entry {
+    pub display: String,
+    pub value: String,
+}
+
+#[derive(Clone, Debug, Default, Serialize)]
+pub struct ControlForm {
+    /// Where the control's content starts (it is found again there on OK).
+    pub at: Value,
+    pub kind: String,
+    pub title: String,
+    pub tag: String,
+    pub lock_delete: bool,
+    pub lock_edit: bool,
+    pub temporary: bool,
+    pub multi_line: bool,
+    pub placeholder: String,
+    pub items: Vec<Entry>,
+    pub format: String,
+    pub checked_symbol: String,
+    pub unchecked_symbol: String,
+}
+
+impl ControlForm {
+    /// The form for the control at the caret, if there is one.
+    pub fn read(app: &mut WordApp) -> Option<ControlForm> {
+        let v = app.session.run("developer.control", &json!({})).ok()?;
+        let s = |k: &str| v.get(k).and_then(Value::as_str).unwrap_or("").to_string();
+        let b = |k: &str| v.get(k).and_then(Value::as_bool).unwrap_or(false);
+        let at = v.get("start").cloned().unwrap_or(Value::Null);
+        // The content starts just after the start marker.
+        let at = match serde_json::from_value::<wordcraft_doc::Pos>(at) {
+            Ok(p) => serde_json::to_value(wordcraft_doc::Pos { off: p.off + wordcraft_doc::para::OBJ.len_utf8(), ..p }).unwrap_or(Value::Null),
+            Err(_) => Value::Null,
+        };
+        let items = v
+            .get("items")
+            .and_then(Value::as_array)
+            .map(|a| {
+                a.iter()
+                    .map(|i| Entry {
+                        display: i.get("display").and_then(Value::as_str).unwrap_or("").to_string(),
+                        value: i.get("value").and_then(Value::as_str).unwrap_or("").to_string(),
+                    })
+                    .collect()
+            })
+            .unwrap_or_default();
+        Some(ControlForm {
+            at,
+            kind: s("type"),
+            title: s("title"),
+            tag: s("tag"),
+            lock_delete: b("lockDelete"),
+            lock_edit: b("lockEdit"),
+            temporary: b("temporary"),
+            multi_line: b("multiLine"),
+            placeholder: s("placeholder"),
+            items,
+            format: s("format"),
+            checked_symbol: s("checkedSymbol"),
+            unchecked_symbol: s("uncheckedSymbol"),
+        })
+    }
+
+    /// The `developer.properties` parameters the form stands for.
+    pub fn params(&self) -> Value {
+        let mut v = json!({
+            "at": self.at,
+            "title": self.title,
+            "tag": self.tag,
+            "lockDelete": self.lock_delete,
+            "lockEdit": self.lock_edit,
+            "temporary": self.temporary,
+        });
+        if !self.placeholder.trim().is_empty() {
+            v["placeholder"] = json!(self.placeholder);
+        }
+        match self.kind.as_str() {
+            "plainText" => v["multiLine"] = json!(self.multi_line),
+            "comboBox" | "dropDown" => {
+                v["items"] = json!(
+                    self.items
+                        .iter()
+                        .filter(|e| !e.display.trim().is_empty())
+                        .map(|e| json!({"display": e.display, "value": if e.value.is_empty() { &e.display } else { &e.value }}))
+                        .collect::<Vec<_>>()
+                );
+            }
+            "date" => v["format"] = json!(self.format),
+            "checkBox" => {
+                v["checkedSymbol"] = json!(self.checked_symbol);
+                v["uncheckedSymbol"] = json!(self.unchecked_symbol);
+            }
+            _ => {}
+        }
+        v
+    }
+}
+
+/// Draws the dialog; returns true to close it.
+pub fn body(app: &mut WordApp, ui: &mut Ui, f: &mut ControlForm) -> bool {
+    ui.set_width(420.0);
+    egui::Grid::new("cc_props").num_columns(2).spacing([10.0, 6.0]).show(ui, |ui| {
+        ui.label(tl!("Title"));
+        ui.add(egui::TextEdit::singleline(&mut f.title).desired_width(280.0));
+        ui.end_row();
+        ui.label(tl!("Tag"));
+        ui.add(egui::TextEdit::singleline(&mut f.tag).desired_width(280.0));
+        ui.end_row();
+        if !matches!(f.kind.as_str(), "checkBox" | "picture" | "repeatingSection" | "repeatingSectionItem") {
+            ui.label(tl!("Placeholder text"));
+            ui.add(egui::TextEdit::singleline(&mut f.placeholder).desired_width(280.0));
+            ui.end_row();
+        }
+    });
+    ui.add_space(6.0);
+    ui.checkbox(&mut f.lock_delete, tl!("Can't be deleted"));
+    ui.checkbox(&mut f.lock_edit, tl!("Contents can't be edited"));
+    ui.checkbox(&mut f.temporary, tl!("Remove the control once edited"));
+    match f.kind.as_str() {
+        "plainText" => {
+            ui.checkbox(&mut f.multi_line, tl!("Allow line breaks"));
+        }
+        "comboBox" | "dropDown" => entries(ui, f),
+        "date" => {
+            ui.add_space(6.0);
+            ui.horizontal(|ui| {
+                ui.label(tl!("Date format"));
+                ui.add(egui::TextEdit::singleline(&mut f.format).desired_width(160.0));
+            });
+            ui.horizontal(|ui| {
+                for pic in ["M/d/yyyy", "d.M.yyyy", "yyyy-MM-dd", "dddd, MMMM d, yyyy"] {
+                    if ui.small_button(pic).clicked() {
+                        f.format = pic.to_string();
+                    }
+                }
+            });
+        }
+        "checkBox" => {
+            ui.add_space(6.0);
+            ui.horizontal(|ui| {
+                ui.label(tl!("Checked symbol"));
+                ui.add(egui::TextEdit::singleline(&mut f.checked_symbol).desired_width(40.0));
+                ui.label(tl!("Unchecked symbol"));
+                ui.add(egui::TextEdit::singleline(&mut f.unchecked_symbol).desired_width(40.0));
+            });
+        }
+        _ => {}
+    }
+    let mut done = false;
+    ui.add_space(8.0);
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if ui.button(tl!("Cancel")).clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+                done = true;
+            }
+            if ui.button(egui::RichText::new(tl!("OK")).color(egui::Color32::WHITE)).clicked() {
+                match app.run("developer.properties", f.params()) {
+                    Ok(_) => done = true,
+                    Err(e) => app.status(e),
+                }
+            }
+        });
+    });
+    done
+}
+
+fn entries(ui: &mut Ui, f: &mut ControlForm) {
+    ui.add_space(6.0);
+    ui.label(egui::RichText::new(tl!("List entries")).font(semibold(12.0)));
+    let mut remove = None;
+    egui::Grid::new("cc_entries").num_columns(3).spacing([6.0, 4.0]).show(ui, |ui| {
+        ui.label(egui::RichText::new(tl!("Display text")).small());
+        ui.label(egui::RichText::new(tl!("Value")).small());
+        ui.end_row();
+        for (i, e) in f.items.iter_mut().enumerate() {
+            ui.add(egui::TextEdit::singleline(&mut e.display).desired_width(170.0));
+            ui.add(egui::TextEdit::singleline(&mut e.value).desired_width(140.0));
+            if ui.small_button(tl!("Remove")).clicked() {
+                remove = Some(i);
+            }
+            ui.end_row();
+        }
+    });
+    if let Some(i) = remove
+        && i < f.items.len()
+    {
+        f.items.remove(i);
+    }
+    if f.items.len() < wordcraft_doc::control::MAX_LIST_ITEMS && ui.button(tl!("Add")).clicked() {
+        f.items.push(Entry::default());
+    }
+}
diff --git a/crates/ui-egui/src/dialogs_insert.rs b/crates/ui-egui/src/dialogs_insert.rs
index 58054dacbf..2454aca65b 100644
--- a/crates/ui-egui/src/dialogs_insert.rs
+++ b/crates/ui-egui/src/dialogs_insert.rs
@@ -16,6 +16,9 @@ pub enum InsertDialog {
     Columns(ColumnsForm),
     Symbol(SymbolForm),
     Field(FieldForm),
+    SmartArt(crate::dialogs_smart_art::SmartArtForm),
+    ChartType(crate::dialogs_chart::ChartTypeForm),
+    ChartData(crate::dialogs_chart::ChartDataForm),
 }
 
 impl InsertDialog {
@@ -24,6 +27,10 @@ impl InsertDialog {
             InsertDialog::Columns(_) => "columns",
             InsertDialog::Symbol(_) => "symbol",
             InsertDialog::Field(_) => "field",
+            InsertDialog::SmartArt(_) => "insertSmartArt",
+            InsertDialog::ChartType(f) if f.change => "changeChartType",
+            InsertDialog::ChartType(_) => "insertChart",
+            InsertDialog::ChartData(_) => "chartData",
         }
     }
 
@@ -33,17 +40,27 @@ impl InsertDialog {
             InsertDialog::Columns(_) => "Columns",
             InsertDialog::Symbol(_) => "Symbol",
             InsertDialog::Field(_) => "Field",
+            InsertDialog::SmartArt(_) => "Insert SmartArt",
+            InsertDialog::ChartType(f) if f.change => "Change Chart Type",
+            InsertDialog::ChartType(_) => "Insert Chart",
+            InsertDialog::ChartData(_) => "Edit Data",
         }
     }
 }
 
-/// The dialog `ui.dialog` opens by `name`: `columns`, `symbol`, `specialCharacters` or `field`.
+/// The dialog `ui.dialog` opens by `name`: `columns`, `symbol`, `specialCharacters`, `field`,
+/// `insertChart`, `changeChartType` or `chartData` (the last two for the selected chart), or
+/// `insertSmartArt`.
 pub fn open(name: &str, app: &WordApp) -> Option<InsertDialog> {
     Some(match name {
         "columns" => InsertDialog::Columns(ColumnsForm::read(app)),
         "symbol" => InsertDialog::Symbol(SymbolForm::new(app, 0)),
         "specialCharacters" => InsertDialog::Symbol(SymbolForm::new(app, 1)),
         "field" => InsertDialog::Field(FieldForm::new(app)),
+        "insertSmartArt" => InsertDialog::SmartArt(crate::dialogs_smart_art::SmartArtForm::new(app)),
+        "insertChart" => InsertDialog::ChartType(crate::dialogs_chart::ChartTypeForm::new(app, false)?),
+        "changeChartType" => InsertDialog::ChartType(crate::dialogs_chart::ChartTypeForm::new(app, true)?),
+        "chartData" => InsertDialog::ChartData(crate::dialogs_chart::ChartDataForm::new(app)?),
         _ => return None,
     })
 }
@@ -54,11 +71,14 @@ pub fn body(app: &mut WordApp, ui: &mut Ui, d: &mut InsertDialog) -> bool {
         InsertDialog::Columns(f) => columns_ui(app, ui, f),
         InsertDialog::Symbol(f) => symbol_ui(app, ui, f),
         InsertDialog::Field(f) => field_ui(app, ui, f),
+        InsertDialog::SmartArt(f) => crate::dialogs_smart_art::picker_ui(app, ui, f),
+        InsertDialog::ChartType(f) => crate::dialogs_chart::type_ui(app, ui, f),
+        InsertDialog::ChartData(f) => crate::dialogs_chart::data_ui(app, ui, f),
     }
 }
 
 /// OK / Cancel (or another OK label); returns (ok, cancel). `ok_enabled` greys OK out.
-fn buttons(ui: &mut Ui, ok: &str, cancel: &str, ok_enabled: bool) -> (bool, bool) {
+pub(crate) fn buttons(ui: &mut Ui, ok: &str, cancel: &str, ok_enabled: bool) -> (bool, bool) {
     let mut r = (false, false);
     ui.add_space(8.0);
     ui.horizontal(|ui| {
@@ -101,7 +121,7 @@ pub struct ColumnsForm {
 
 impl ColumnsForm {
     fn k() -> f32 {
-        wordcraft_geom::Unit::default().pt_per_unit()
+        crate::options::unit().pt_per_unit()
     }
 
     pub fn read(app: &WordApp) -> ColumnsForm {
@@ -332,7 +352,7 @@ fn columns_preview(ui: &mut Ui, f: &ColumnsForm, t: &Tokens) {
 
 fn columns_ui(app: &mut WordApp, ui: &mut Ui, f: &mut ColumnsForm) -> bool {
     let t = Tokens::get(ui.ctx());
-    let unit = wordcraft_geom::Unit::default();
+    let unit = crate::options::unit();
     ui.set_width(420.0);
     ui.label(egui::RichText::new(tl!("Presets")).font(semibold(12.5)));
     let current = f.current_preset();
diff --git a/crates/ui-egui/src/dialogs_layout.rs b/crates/ui-egui/src/dialogs_layout.rs
new file mode 100644
index 0000000000..73c5de7cac
--- /dev/null
+++ b/crates/ui-egui/src/dialogs_layout.rs
@@ -0,0 +1,767 @@
+//! Layout, Review and Mailings dialogs (#407): Line Numbers (Layout › Line Numbers › Line
+//! Numbering Options…), Hyphenation (Hyphenation Options… and Manual…), Language (Review ›
+//! Language), and Envelopes and Labels (Mailings › Create). Each ends by running a command
+//! (`layout.lineNumbers`, `layout.hyphenation`, `layout.manualHyphenation` with `caret.set` and
+//! `text.optionalHyphen`, `review.language`, `mailings.envelopes`, `mailings.labels`), so scripts
+//! and agents get the same result without the dialog. Shown through
+//! [`crate::dialogs::Dialog::Layout`].
+
+use egui::{Color32, Ui, vec2};
+use serde::Serialize;
+use serde_json::{Value, json};
+
+use wordcraft_doc::section::LineNumberRestart;
+use wordcraft_engine::cmd::mailings::{ENVELOPE_SIZES, LABEL_PRODUCTS};
+
+use crate::WordApp;
+use crate::theme::semibold;
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(tag = "form", rename_all = "camelCase")]
+pub enum LayoutDialog {
+    LineNumbers(LineNumbersForm),
+    Hyphenation(HyphenationForm),
+    ManualHyphenation(ManualForm),
+    Language(LanguageForm),
+    Envelopes(EnvelopeForm),
+    Labels(LabelsForm),
+}
+
+impl LayoutDialog {
+    pub fn name(&self) -> &'static str {
+        match self {
+            LayoutDialog::LineNumbers(_) => "lineNumbers",
+            LayoutDialog::Hyphenation(_) => "hyphenation",
+            LayoutDialog::ManualHyphenation(_) => "manualHyphenation",
+            LayoutDialog::Language(_) => "language",
+            LayoutDialog::Envelopes(_) => "envelopes",
+            LayoutDialog::Labels(_) => "labels",
+        }
+    }
+
+    /// The window title (English; the caller translates it).
+    pub fn title(&self) -> &'static str {
+        match self {
+            LayoutDialog::LineNumbers(_) => "Line Numbers",
+            LayoutDialog::Hyphenation(_) => "Hyphenation",
+            LayoutDialog::ManualHyphenation(_) => "Manual Hyphenation",
+            LayoutDialog::Language(_) => "Language",
+            LayoutDialog::Envelopes(_) => "Envelopes",
+            LayoutDialog::Labels(_) => "Labels",
+        }
+    }
+}
+
+/// The dialog `ui.dialog` opens by `name`.
+pub fn open(name: &str, app: &mut WordApp) -> Option<LayoutDialog> {
+    Some(match name {
+        "lineNumbers" => LayoutDialog::LineNumbers(LineNumbersForm::read(app)),
+        "hyphenation" => LayoutDialog::Hyphenation(HyphenationForm::read(app)),
+        "manualHyphenation" => LayoutDialog::ManualHyphenation(ManualForm::start(app)),
+        "language" => LayoutDialog::Language(LanguageForm::read(app)),
+        "envelopes" => LayoutDialog::Envelopes(EnvelopeForm::read(app)),
+        "labels" => LayoutDialog::Labels(LabelsForm::read(app)),
+        _ => return None,
+    })
+}
+
+/// Draws the dialog; returns true to close it.
+pub fn body(app: &mut WordApp, ui: &mut Ui, d: &mut LayoutDialog) -> bool {
+    match d {
+        LayoutDialog::LineNumbers(f) => line_numbers_ui(app, ui, f),
+        LayoutDialog::Hyphenation(f) => hyphenation_ui(app, ui, f),
+        LayoutDialog::ManualHyphenation(f) => manual_ui(app, ui, f),
+        LayoutDialog::Language(f) => language_ui(app, ui, f),
+        LayoutDialog::Envelopes(f) => envelopes_ui(app, ui, f),
+        LayoutDialog::Labels(f) => labels_ui(app, ui, f),
+    }
+}
+
+/// The accent button and Cancel; returns (ok, cancel).
+fn buttons(ui: &mut Ui, ok: &str, ok_enabled: bool) -> (bool, bool) {
+    let mut r = (false, false);
+    ui.add_space(8.0);
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if ui.button(tl!("Cancel")).clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+                r.1 = true;
+            }
+            let okb = ui.add_enabled(ok_enabled, egui::Button::new(egui::RichText::new(tl!(ok)).color(Color32::WHITE)).fill(crate::theme::APP_COLOR));
+            if okb.clicked() {
+                r.0 = true;
+            }
+        });
+    });
+    r
+}
+
+fn heading(ui: &mut Ui, s: &str) {
+    ui.add_space(4.0);
+    ui.label(egui::RichText::new(tl!(s)).font(semibold(12.5)));
+}
+
+/// Runs a dialog's command; a refusal shows in the status bar and keeps the dialog open.
+fn run(app: &mut WordApp, id: &str, params: Value) -> bool {
+    match app.run(id, params) {
+        Ok(_) => true,
+        Err(e) => {
+            app.status(e);
+            false
+        }
+    }
+}
+
+fn unit() -> wordcraft_geom::Unit {
+    crate::options::unit()
+}
+
+// ---------------------------------------------------------------------------------------------
+// Line Numbers
+
+/// The Line Numbers dialog's fields. `distance` is in the interface unit.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LineNumbersForm {
+    pub on: bool,
+    pub start: u32,
+    /// From text: automatic, or `distance`.
+    pub auto_distance: bool,
+    pub distance: f32,
+    pub count_by: u32,
+    /// `restartPage`, `restartSection` or `continuous`.
+    pub restart: String,
+}
+
+impl LineNumbersForm {
+    pub fn read(app: &WordApp) -> LineNumbersForm {
+        let sp = wordcraft_engine::cmd::page::sect(&app.session);
+        let l = sp.line_numbers.clone();
+        let cur = l.clone().unwrap_or_default();
+        LineNumbersForm {
+            on: l.is_some(),
+            start: cur.start.max(1),
+            auto_distance: cur.distance <= 0.0,
+            distance: if cur.distance > 0.0 { cur.distance / unit().pt_per_unit() } else { 0.25 * 72.0 / unit().pt_per_unit() },
+            count_by: cur.count_by.max(1),
+            restart: match cur.restart {
+                LineNumberRestart::Page => "restartPage",
+                LineNumberRestart::Section => "restartSection",
+                LineNumberRestart::Continuous => "continuous",
+            }
+            .into(),
+        }
+    }
+
+    /// `layout.lineNumbers` parameters.
+    pub fn params(&self) -> Value {
+        if !self.on {
+            return json!({"value": "none"});
+        }
+        let distance = if self.auto_distance { 0.0 } else { (self.distance * unit().pt_per_unit()).max(0.0) };
+        json!({"value": self.restart, "start": self.start, "countBy": self.count_by, "distance": distance})
+    }
+}
+
+fn line_numbers_ui(app: &mut WordApp, ui: &mut Ui, f: &mut LineNumbersForm) -> bool {
+    ui.checkbox(&mut f.on, tl!("Add line numbering"));
+    ui.add_enabled_ui(f.on, |ui| {
+        egui::Grid::new("lnum").num_columns(2).spacing(vec2(10.0, 6.0)).show(ui, |ui| {
+            ui.label(tl!("Start at:"));
+            ui.add(egui::DragValue::new(&mut f.start).range(1..=32_767));
+            ui.end_row();
+            ui.label(tl!("From text:"));
+            ui.horizontal(|ui| {
+                ui.checkbox(&mut f.auto_distance, tl!("Auto"));
+                ui.add_enabled(
+                    !f.auto_distance,
+                    egui::DragValue::new(&mut f.distance)
+                        .speed(0.01)
+                        .range(0.0..=22.0 * 72.0 / unit().pt_per_unit())
+                        .suffix(unit().suffix())
+                        .max_decimals(2),
+                );
+            });
+            ui.end_row();
+            ui.label(tl!("Count by:"));
+            ui.add(egui::DragValue::new(&mut f.count_by).range(1..=100));
+            ui.end_row();
+        });
+        heading(ui, "Numbering:");
+        for (v, l) in [("restartPage", "Restart Each Page"), ("restartSection", "Restart Each Section"), ("continuous", "Continuous")] {
+            ui.radio_value(&mut f.restart, v.to_string(), tl!(l));
+        }
+    });
+    let (ok, cancel) = buttons(ui, "OK", true);
+    if ok {
+        return run(app, "layout.lineNumbers", f.params());
+    }
+    cancel
+}
+
+// ---------------------------------------------------------------------------------------------
+// Hyphenation
+
+/// The Hyphenation dialog's fields. `zone` is in the interface unit; `limit` 0 = no limit.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HyphenationForm {
+    pub auto: bool,
+    pub caps: bool,
+    pub zone: f32,
+    pub limit: u32,
+}
+
+impl HyphenationForm {
+    pub fn read(app: &WordApp) -> HyphenationForm {
+        let s = &app.session.doc.settings;
+        HyphenationForm {
+            auto: s.auto_hyphenation,
+            caps: s.hyphenate_caps,
+            zone: s.hyphenation_zone.max(0.0) / unit().pt_per_unit(),
+            limit: s.consecutive_hyphen_limit,
+        }
+    }
+
+    /// `layout.hyphenation` parameters.
+    pub fn params(&self) -> Value {
+        json!({"value": self.auto, "caps": self.caps, "zone": (self.zone * unit().pt_per_unit()).max(0.0), "limit": self.limit})
+    }
+}
+
+fn hyphenation_ui(app: &mut WordApp, ui: &mut Ui, f: &mut HyphenationForm) -> bool {
+    ui.checkbox(&mut f.auto, tl!("Automatically hyphenate document"));
+    ui.checkbox(&mut f.caps, tl!("Hyphenate words in CAPS"));
+    egui::Grid::new("hyph").num_columns(2).spacing(vec2(10.0, 6.0)).show(ui, |ui| {
+        ui.label(tl!("Hyphenation zone:"));
+        ui.add(egui::DragValue::new(&mut f.zone).speed(0.01).range(0.0..=22.0 * 72.0 / unit().pt_per_unit()).suffix(unit().suffix()).max_decimals(2));
+        ui.end_row();
+        ui.label(tl!("Limit consecutive hyphens to:"));
+        let no_limit = tl!("No limit").to_string();
+        ui.add(
+            egui::DragValue::new(&mut f.limit).range(0..=99).custom_formatter(move |n, _| if n < 0.5 { no_limit.clone() } else { format!("{n:.0}") }),
+        );
+        ui.end_row();
+    });
+    ui.add_space(6.0);
+    let manual = ui.button(tl!("Manual…")).clicked();
+    let (ok, cancel) = buttons(ui, "OK", true);
+    if (ok || manual) && !run(app, "layout.hyphenation", f.params()) {
+        return false;
+    }
+    // Manual… keeps what was set here and moves on to manual hyphenation.
+    if manual {
+        app.dialog = crate::dialogs::Dialog::open("manualHyphenation", app);
+    }
+    ok || cancel || manual
+}
+
+// ---------------------------------------------------------------------------------------------
+// Manual hyphenation
+
+/// One word at a time: where it may be hyphenated and where the hyphen goes.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ManualForm {
+    pub word: String,
+    /// Where the word starts.
+    pub pos: Value,
+    /// Char indices a hyphen may go before.
+    pub points: Vec<usize>,
+    pub choice: usize,
+    /// No more words.
+    pub done: bool,
+}
+
+impl ManualForm {
+    /// From the selection, or from the start of the document.
+    pub fn start(app: &mut WordApp) -> ManualForm {
+        let from = if app.session.sel.is_collapsed() { Value::Null } else { wordcraft_engine::cmd::pos_json(&app.session.sel.ordered().0) };
+        let from = if from.is_null() { json!({"block": 0, "off": 0}) } else { from };
+        Self::next(app, from)
+    }
+
+    /// The next word from `from`.
+    pub fn next(app: &mut WordApp, from: Value) -> ManualForm {
+        let c = app.session.run("layout.manualHyphenation", &json!({"from": from})).unwrap_or_else(|_| json!({"done": true}));
+        let points: Vec<usize> =
+            c.get("points").and_then(Value::as_array).map(|a| a.iter().filter_map(Value::as_u64).map(|n| n as usize).collect()).unwrap_or_default();
+        // The word is selected, so the page shows which one is asked about.
+        if let (Some(pos), Some(word)) = (c.get("pos"), c.get("word").and_then(Value::as_str)) {
+            let end = with_off(pos, pos.get("off").and_then(Value::as_u64).unwrap_or(0).saturating_add(word.len() as u64));
+            let _ = app.session.run("select.range", &json!({"anchor": pos, "focus": end}));
+        }
+        ManualForm {
+            word: c.get("word").and_then(Value::as_str).unwrap_or("").to_string(),
+            pos: c.get("pos").cloned().unwrap_or(Value::Null),
+            choice: c.get("suggest").and_then(Value::as_u64).map(|n| n as usize).or_else(|| points.last().copied()).unwrap_or(0),
+            points,
+            done: c.get("done").and_then(Value::as_bool).unwrap_or(false) || c.get("word").is_none(),
+        }
+    }
+
+    /// The word's position plus `bytes`.
+    fn at(&self, bytes: usize) -> Value {
+        let off = self.pos.get("off").and_then(Value::as_u64).unwrap_or(0);
+        with_off(&self.pos, off.saturating_add(bytes as u64))
+    }
+
+    fn byte_of(&self, ch: usize) -> usize {
+        self.word.char_indices().nth(ch).map_or(self.word.len(), |(i, _)| i)
+    }
+
+    /// Yes: an optional hyphen at the chosen point, then the next word.
+    pub fn accept(&mut self, app: &mut WordApp) {
+        let at = self.at(self.byte_of(self.choice));
+        if run(app, "caret.set", json!({"pos": at})) && run(app, "text.optionalHyphen", json!({})) {
+            let after = self.at(self.word.len() + '\u{ad}'.len_utf8());
+            *self = Self::next(app, after);
+        }
+    }
+
+    /// No: leave the word alone and go to the next one.
+    pub fn skip(&mut self, app: &mut WordApp) {
+        let after = self.at(self.word.len());
+        *self = Self::next(app, after);
+    }
+}
+
+/// A position (`{"story", "path", "off"}`) at another offset in the same paragraph.
+fn with_off(pos: &Value, off: u64) -> Value {
+    let mut p = pos.as_object().cloned().unwrap_or_default();
+    p.insert("off".into(), json!(off));
+    Value::Object(p)
+}
+
+fn manual_ui(app: &mut WordApp, ui: &mut Ui, f: &mut ManualForm) -> bool {
+    if f.done {
+        ui.label(tl!("Manual hyphenation is complete."));
+        ui.add_space(8.0);
+        return ui.button(tl!("Close")).clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape) || i.key_pressed(egui::Key::Enter));
+    }
+    ui.label(tl!("Hyphenate at:"));
+    // The word with every possible break; the chosen one is the hyphen that will be inserted.
+    ui.horizontal(|ui| {
+        ui.spacing_mut().item_spacing.x = 0.0;
+        let mut from = 0;
+        for pt in f.points.clone() {
+            ui.label(egui::RichText::new(f.word.chars().skip(from).take(pt.saturating_sub(from)).collect::<String>()).size(16.0));
+            if ui.selectable_label(f.choice == pt, egui::RichText::new("-").size(16.0)).clicked() {
+                f.choice = pt;
+            }
+            from = pt;
+        }
+        ui.label(egui::RichText::new(f.word.chars().skip(from).collect::<String>()).size(16.0));
+    });
+    ui.add_space(8.0);
+    let mut close = false;
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if ui.button(tl!("Cancel")).clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+                close = true;
+            }
+            if ui.button(tl!("No")).clicked() {
+                f.skip(app);
+            }
+            if ui.add(egui::Button::new(egui::RichText::new(tl!("Yes")).color(Color32::WHITE)).fill(crate::theme::APP_COLOR)).clicked() {
+                f.accept(app);
+            }
+        });
+    });
+    close
+}
+
+// ---------------------------------------------------------------------------------------------
+// Language
+
+/// Proofing languages offered, by BCP 47 tag, with their English names (translated for display).
+pub const LANGUAGES: [(&str, &str); 29] = [
+    ("en-US", "English (United States)"),
+    ("en-GB", "English (United Kingdom)"),
+    ("de-DE", "German (Germany)"),
+    ("fr-FR", "French (France)"),
+    ("es-ES", "Spanish (Spain)"),
+    ("es-MX", "Spanish (Mexico)"),
+    ("it-IT", "Italian"),
+    ("pt-BR", "Portuguese (Brazil)"),
+    ("pt-PT", "Portuguese (Portugal)"),
+    ("nl-NL", "Dutch"),
+    ("sv-SE", "Swedish"),
+    ("da-DK", "Danish"),
+    ("nb-NO", "Norwegian (Bokmål)"),
+    ("fi-FI", "Finnish"),
+    ("et-EE", "Estonian"),
+    ("pl-PL", "Polish"),
+    ("cs-CZ", "Czech"),
+    ("uk-UA", "Ukrainian"),
+    ("ru-RU", "Russian"),
+    ("sr-Cyrl-RS", "Serbian (Cyrillic)"),
+    ("sr-Latn-RS", "Serbian (Latin)"),
+    ("el-GR", "Greek"),
+    ("tr-TR", "Turkish"),
+    ("ja-JP", "Japanese"),
+    ("zh-CN", "Chinese (Simplified)"),
+    ("zh-TW", "Chinese (Traditional)"),
+    ("ko-KR", "Korean"),
+    ("ar-SA", "Arabic"),
+    ("he-IL", "Hebrew"),
+];
+
+/// The Language dialog's fields.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LanguageForm {
+    pub lang: String,
+    pub no_proof: bool,
+    pub detect: bool,
+}
+
+impl LanguageForm {
+    pub fn read(app: &WordApp) -> LanguageForm {
+        let s = &app.session;
+        let here = s.typing_props();
+        let lang = here.lang.clone().or_else(|| s.doc.styles.default_chr.lang.clone()).unwrap_or_else(|| "en-US".into());
+        LanguageForm { lang, no_proof: here.no_proof.unwrap_or(false), detect: s.prefs.detect_language }
+    }
+
+    /// `review.language` parameters for OK.
+    pub fn params(&self) -> Value {
+        json!({"lang": self.lang, "noProof": self.no_proof, "detect": self.detect})
+    }
+}
+
+/// A language's name in the interface language (the tag itself when we don't know it).
+fn language_name(tag: &str) -> String {
+    LANGUAGES.iter().find(|(t, _)| t.eq_ignore_ascii_case(tag)).map(|(_, n)| tl!(n).to_string()).unwrap_or_else(|| tag.to_string())
+}
+
+fn language_ui(app: &mut WordApp, ui: &mut Ui, f: &mut LanguageForm) -> bool {
+    ui.label(tl!("Mark selected text as:"));
+    let mut list: Vec<(String, String)> = LANGUAGES.iter().map(|(t, _)| (t.to_string(), language_name(t))).collect();
+    if !LANGUAGES.iter().any(|(t, _)| t.eq_ignore_ascii_case(&f.lang)) {
+        list.push((f.lang.clone(), f.lang.clone()));
+    }
+    list.sort_by_key(|a| a.1.to_lowercase());
+    egui::Frame::NONE.stroke(egui::Stroke::new(1.0, crate::theme::Tokens::get(ui.ctx()).border_strong)).inner_margin(4.0).show(ui, |ui| {
+        egui::ScrollArea::vertical().max_height(220.0).min_scrolled_height(220.0).show(ui, |ui| {
+            ui.set_min_width(300.0);
+            for (tag, name) in &list {
+                let on = f.lang.eq_ignore_ascii_case(tag);
+                let r = ui.selectable_label(on, name.as_str());
+                if r.clicked() {
+                    f.lang = tag.clone();
+                }
+            }
+        });
+    });
+    ui.add_space(4.0);
+    ui.checkbox(&mut f.no_proof, tl!("Do not check spelling or grammar"));
+    ui.checkbox(&mut f.detect, tl!("Detect language automatically"));
+    ui.add_space(4.0);
+    let set_default = ui.button(tl!("Set As Default")).clicked();
+    if set_default && run(app, "review.language", json!({"lang": f.lang, "default": true, "detect": f.detect})) {
+        app.status(crate::i18n::fmt(tl!("{language} is now the document's default language."), &[("language", &language_name(&f.lang))]));
+    }
+    let (ok, cancel) = buttons(ui, "OK", true);
+    if ok {
+        return run(app, "review.language", f.params());
+    }
+    cancel
+}
+
+// ---------------------------------------------------------------------------------------------
+// Envelopes
+
+/// The Envelopes dialog's fields. `size` indexes [`ENVELOPE_SIZES`].
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct EnvelopeForm {
+    pub delivery: String,
+    pub ret: String,
+    pub omit_return: bool,
+    pub size: usize,
+}
+
+impl EnvelopeForm {
+    /// The delivery address starts as the selected text (an address in the letter).
+    pub fn read(app: &WordApp) -> EnvelopeForm {
+        let sel = if app.session.sel.is_collapsed() { String::new() } else { app.session.selected_text() };
+        EnvelopeForm { delivery: sel.trim().replace("\r\n", "\n").replace('\r', "\n"), ret: String::new(), omit_return: false, size: 0 }
+    }
+
+    /// `mailings.envelopes` parameters; `add` puts the envelope at the start of this document.
+    pub fn params(&self, add: bool) -> Value {
+        let size = ENVELOPE_SIZES.get(self.size).map_or("Envelope #10", |s| s.0);
+        let ret = if self.omit_return { "" } else { self.ret.as_str() };
+        json!({"delivery": self.delivery, "return": ret, "size": size, "add": add})
+    }
+}
+
+fn envelopes_ui(app: &mut WordApp, ui: &mut Ui, f: &mut EnvelopeForm) -> bool {
+    ui.label(tl!("Delivery address:"));
+    ui.add(egui::TextEdit::multiline(&mut f.delivery).desired_rows(4).desired_width(340.0));
+    ui.horizontal(|ui| {
+        ui.label(tl!("Return address:"));
+        ui.checkbox(&mut f.omit_return, tl!("Omit"));
+    });
+    ui.add_enabled(!f.omit_return, egui::TextEdit::multiline(&mut f.ret).desired_rows(3).desired_width(340.0));
+    ui.horizontal(|ui| {
+        ui.label(tl!("Envelope size:"));
+        let label = |i: usize| ENVELOPE_SIZES.get(i).map(|(n, w, h)| envelope_label(n, *w, *h)).unwrap_or_default();
+        egui::ComboBox::from_id_salt("env_size").selected_text(label(f.size)).width(220.0).show_ui(ui, |ui| {
+            for i in 0..ENVELOPE_SIZES.len() {
+                ui.selectable_value(&mut f.size, i, label(i));
+            }
+        });
+    });
+    let ready = !f.delivery.trim().is_empty();
+    ui.add_space(8.0);
+    let (mut add, mut new, mut cancel) = (false, false, false);
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            cancel = ui.button(tl!("Cancel")).clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape));
+            new = ui.add_enabled(ready, egui::Button::new(tl!("New Document"))).clicked();
+            add = ui
+                .add_enabled(
+                    ready,
+                    egui::Button::new(egui::RichText::new(tl!("Add to Document")).color(Color32::WHITE)).fill(crate::theme::APP_COLOR),
+                )
+                .clicked();
+        });
+    });
+    if add || new {
+        return run(app, "mailings.envelopes", f.params(add));
+    }
+    cancel
+}
+
+/// `DL  110 × 220 mm` / `#10  4.13 × 9.5 in`: metric sizes in millimetres, the others in inches.
+fn envelope_label(name: &str, w: f32, h: f32) -> String {
+    let short = name.strip_prefix("Envelope ").unwrap_or(name);
+    if short.starts_with('#') || short == "Monarch" {
+        let i = |pt: f32| ((pt / 72.0) * 100.0).round() / 100.0;
+        format!("{short}   {} × {} in", i(h), i(w))
+    } else {
+        let mm = |pt: f32| (pt * 25.4 / 72.0).round();
+        format!("{short}   {} × {} mm", mm(h), mm(w))
+    }
+}
+
+// ---------------------------------------------------------------------------------------------
+// Labels
+
+/// The Labels dialog's fields. `product` indexes [`LABEL_PRODUCTS`]; `row`/`col` count from 1.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct LabelsForm {
+    pub text: String,
+    pub product: usize,
+    pub single: bool,
+    pub row: usize,
+    pub col: usize,
+    /// One label per recipient (when a recipient list is loaded).
+    pub recipients: bool,
+}
+
+impl LabelsForm {
+    pub fn read(app: &WordApp) -> LabelsForm {
+        let sel = if app.session.sel.is_collapsed() { String::new() } else { app.session.selected_text() };
+        LabelsForm {
+            text: sel.trim().replace("\r\n", "\n").replace('\r', "\n"),
+            product: 0,
+            single: false,
+            row: 1,
+            col: 1,
+            recipients: !app.session.merge.rows.is_empty(),
+        }
+    }
+
+    /// `mailings.labels` parameters.
+    pub fn params(&self) -> Value {
+        let id = LABEL_PRODUCTS.get(self.product).map_or("letter-3x10", |p| p.id);
+        let mut v = json!({"text": self.text, "product": id, "fromRecipients": self.recipients && !self.single});
+        if self.single {
+            v["single"] = json!({"row": self.row, "col": self.col});
+        }
+        v
+    }
+}
+
+/// `Address labels, 3 × 10, 2.625" × 1" (Letter)`.
+fn product_label(i: usize) -> String {
+    let Some(p) = LABEL_PRODUCTS.get(i) else { return String::new() };
+    let kind = match p.kind {
+        "shipping" => tl!("Shipping labels"),
+        "return" => tl!("Return address labels"),
+        _ => tl!("Address labels"),
+    };
+    format!("{kind}, {} × {}, {} ({})", p.cols, p.rows, p.size_text(), p.paper)
+}
+
+fn labels_ui(app: &mut WordApp, ui: &mut Ui, f: &mut LabelsForm) -> bool {
+    let has_recipients = !app.session.merge.rows.is_empty();
+    if has_recipients {
+        ui.checkbox(&mut f.recipients, tl!("One label per recipient"));
+    }
+    ui.add_enabled_ui(!(has_recipients && f.recipients && !f.single), |ui| {
+        ui.label(tl!("Address:"));
+        ui.add(egui::TextEdit::multiline(&mut f.text).desired_rows(4).desired_width(340.0));
+    });
+    ui.horizontal(|ui| {
+        ui.label(tl!("Label:"));
+        egui::ComboBox::from_id_salt("label_product").selected_text(product_label(f.product)).width(300.0).show_ui(ui, |ui| {
+            for i in 0..LABEL_PRODUCTS.len() {
+                ui.selectable_value(&mut f.product, i, product_label(i));
+            }
+        });
+    });
+    let (rows, cols) = LABEL_PRODUCTS.get(f.product).map_or((1, 1), |p| (p.rows, p.cols));
+    heading(ui, "Print");
+    ui.radio_value(&mut f.single, false, tl!("Full page of the same label"));
+    ui.horizontal(|ui| {
+        ui.radio_value(&mut f.single, true, tl!("Single label"));
+        ui.add_enabled_ui(f.single, |ui| {
+            ui.label(tl!("Row:"));
+            ui.add(egui::DragValue::new(&mut f.row).range(1..=rows));
+            ui.label(tl!("Column:"));
+            ui.add(egui::DragValue::new(&mut f.col).range(1..=cols));
+        });
+    });
+    f.row = f.row.clamp(1, rows.max(1));
+    f.col = f.col.clamp(1, cols.max(1));
+    let ready = (has_recipients && f.recipients && !f.single) || !f.text.trim().is_empty();
+    let (ok, cancel) = buttons(ui, "New Document", ready);
+    if ok {
+        return run(app, "mailings.labels", f.params());
+    }
+    cancel
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+    use wordcraft_engine::Session;
+
+    use super::*;
+    use crate::dialogs::Dialog;
+    use crate::{Services, WordApp};
+
+    fn app() -> WordApp {
+        WordApp::new(Session::new(wordcraft_doc::Document::from_text("Dear Jo,\nThanks.")), Services::default())
+    }
+
+    fn form(a: &mut WordApp) -> LayoutDialog {
+        let Some(Dialog::Layout(d)) = a.dialog.take() else { panic!("no dialog: {:?}", a.dialog) };
+        *d
+    }
+
+    /// #407: Line Numbering Options… opens with the section's numbering and OK sets every
+    /// option; Hyphenation Options sets the document's hyphenation settings.
+    #[test]
+    fn line_numbers_and_hyphenation_options_apply() {
+        let mut a = app();
+        a.run("ui.dialog", json!({"name": "lineNumbers"})).unwrap();
+        let LayoutDialog::LineNumbers(mut f) = form(&mut a) else { panic!("line numbers") };
+        assert!(!f.on && f.auto_distance && f.restart == "restartPage");
+        f.on = true;
+        f.start = 10;
+        f.count_by = 5;
+        f.restart = "continuous".into();
+        a.run("layout.lineNumbers", f.params()).unwrap();
+        let l = a.session.doc.last_section.line_numbers.clone().unwrap();
+        assert_eq!((l.start, l.count_by, l.distance, l.restart), (10, 5, 0.0, LineNumberRestart::Continuous));
+        a.run("ui.dialog", json!({"name": "lineNumbers"})).unwrap();
+        assert!(matches!(form(&mut a), LayoutDialog::LineNumbers(f) if f.on && f.start == 10 && f.restart == "continuous"));
+
+        a.run("ui.dialog", json!({"name": "hyphenation"})).unwrap();
+        let LayoutDialog::Hyphenation(mut h) = form(&mut a) else { panic!("hyphenation") };
+        assert!(!h.auto && h.caps && h.limit == 0);
+        (h.auto, h.caps, h.limit) = (true, false, 2);
+        a.run("layout.hyphenation", h.params()).unwrap();
+        let s = &a.session.doc.settings;
+        assert!(s.auto_hyphenation && !s.hyphenate_caps && s.consecutive_hyphen_limit == 2);
+        assert!((s.hyphenation_zone - 18.0).abs() < 0.01, "zone untouched: {}", s.hyphenation_zone);
+    }
+
+    /// #755: the Line Numbers "From text" distance and the Hyphenation zone follow the
+    /// File › Options unit (centimeters here); `params` sends points whatever the unit.
+    #[test]
+    fn line_numbers_and_hyphenation_measure_in_the_options_unit() {
+        let mut a = app();
+        a.run("file.options", json!({"units": "centimeters"})).unwrap();
+        a.run("layout.lineNumbers", json!({"value": "restartPage", "start": 1, "countBy": 1, "distance": 18.0})).unwrap();
+        a.run("ui.dialog", json!({"name": "lineNumbers"})).unwrap();
+        let LayoutDialog::LineNumbers(f) = form(&mut a) else { panic!("line numbers") };
+        assert!(!f.auto_distance);
+        let cm = 18.0 / wordcraft_geom::PT_PER_CM;
+        assert!((f.distance - cm).abs() < 0.01, "distance was {} cm", f.distance);
+        let sent = f.params()["distance"].as_f64().unwrap_or_default();
+        assert!((sent - 18.0).abs() < 0.05, "params sent {sent} pt");
+
+        a.run("layout.hyphenation", json!({"value": true, "zone": 36.0})).unwrap();
+        a.run("ui.dialog", json!({"name": "hyphenation"})).unwrap();
+        let LayoutDialog::Hyphenation(h) = form(&mut a) else { panic!("hyphenation") };
+        assert!((h.zone - 36.0 / wordcraft_geom::PT_PER_CM).abs() < 0.01, "zone was {} cm", h.zone);
+        let sent = h.params()["zone"].as_f64().unwrap_or_default();
+        assert!((sent - 36.0).abs() < 0.05, "params sent {sent} pt");
+    }
+
+    /// #407: the Language button opens the dialog (scripts with a language never see it); OK
+    /// marks the selection and "do not check", Set As Default changes the document default.
+    #[test]
+    fn language_dialog_marks_the_selection() {
+        let mut a = app();
+        a.run("select.all", json!({})).unwrap();
+        assert_eq!(a.run("review.language", json!({})).unwrap(), json!({"pending": "language"}));
+        let LayoutDialog::Language(mut f) = form(&mut a) else { panic!("language") };
+        assert_eq!(f.lang, "en-US");
+        f.lang = "sr-Latn-RS".into();
+        f.no_proof = true;
+        a.run("review.language", f.params()).unwrap();
+        let c = a.session.typing_props();
+        assert_eq!((c.lang.as_deref(), c.no_proof), (Some("sr-Latn-RS"), Some(true)));
+        a.run("review.language", json!({"lang": "fr-FR", "default": true})).unwrap();
+        assert_eq!(a.session.doc.styles.default_chr.lang.as_deref(), Some("fr-FR"));
+        assert!(a.dialog.is_none());
+        assert_eq!(language_name("xx-YY"), "xx-YY", "an unknown tag shows as itself");
+    }
+
+    /// #407: Envelopes starts from the selected address; Add to Document puts an envelope
+    /// section before the letter without asking to save (nothing is replaced).
+    #[test]
+    fn envelope_dialog_adds_an_envelope_section() {
+        let mut a = app();
+        a.run("select.paragraph", json!({})).unwrap();
+        a.session.dirty = true;
+        assert_eq!(a.run("mailings.envelopes", json!({})).unwrap(), json!({"pending": "envelopes"}));
+        let LayoutDialog::Envelopes(mut f) = form(&mut a) else { panic!("envelopes") };
+        assert_eq!(f.delivery, "Dear Jo,");
+        f.delivery = "Jo Doe\n1 Main St".into();
+        f.ret = "Me".into();
+        f.size = ENVELOPE_SIZES.iter().position(|s| s.0 == "Envelope DL").unwrap();
+        let document = a.session.document_id();
+        a.run("mailings.envelopes", f.params(true)).unwrap();
+        assert!(a.dialog.is_none(), "no save prompt");
+        assert_eq!(a.session.document_id(), document);
+        let secs = a.session.doc.sections();
+        assert_eq!(secs.len(), 2);
+        assert!((secs[0].1.page_w - 623.6).abs() < 0.1);
+        assert!(a.session.doc.plain_text(wordcraft_doc::StoryRef::Body).contains("Thanks."));
+    }
+
+    /// #407: Labels builds a new document of the chosen sheet, or a single label.
+    #[test]
+    fn labels_dialog_builds_a_sheet() {
+        let mut a = app();
+        assert_eq!(a.run("mailings.labels", json!({})).unwrap(), json!({"pending": "labels"}));
+        let LayoutDialog::Labels(mut f) = form(&mut a) else { panic!("labels") };
+        f.text = "Ada Lovelace\nLondon".into();
+        f.product = LABEL_PRODUCTS.iter().position(|p| p.id == "a4-3x8").unwrap();
+        let r = a.session.run("mailings.labels", &f.params()).unwrap();
+        assert_eq!(r["labels"], 24);
+        assert_eq!(a.session.doc.plain_text(wordcraft_doc::StoryRef::Body).matches("Ada Lovelace").count(), 24);
+        f.single = true;
+        (f.row, f.col) = (3, 2);
+        assert_eq!(a.session.run("mailings.labels", &f.params()).unwrap()["filled"], 1);
+        assert!(product_label(f.product).contains("63.5 × 33.9 mm (A4)"));
+    }
+}
diff --git a/crates/ui-egui/src/dialogs_lists.rs b/crates/ui-egui/src/dialogs_lists.rs
index 61380655be..eb49441626 100644
--- a/crates/ui-egui/src/dialogs_lists.rs
+++ b/crates/ui-egui/src/dialogs_lists.rs
@@ -52,7 +52,7 @@ pub struct LevelForm {
 
 impl LevelForm {
     fn read(i: usize, v: &Value) -> LevelForm {
-        let k = wordcraft_geom::Unit::default().pt_per_unit();
+        let k = crate::options::unit().pt_per_unit();
         let s = |key: &str| v.get(key).and_then(Value::as_str).unwrap_or("").to_string();
         let f = |key: &str| v.get(key).and_then(Value::as_f64).map(|x| x as f32 / k).filter(|x| x.is_finite());
         let restart_after = v.get("restartAfter").and_then(Value::as_u64);
@@ -78,7 +78,7 @@ impl LevelForm {
 
     /// The level as `list.define` takes it.
     pub fn params(&self, i: usize) -> Value {
-        let k = wordcraft_geom::Unit::default().pt_per_unit();
+        let k = crate::options::unit().pt_per_unit();
         json!({
             "format": self.format,
             "text": self.text,
@@ -162,7 +162,7 @@ impl ListForm {
 
 /// Define New Multilevel List. Returns true to close.
 pub fn define_list(app: &mut WordApp, ui: &mut Ui, f: &mut ListForm) -> bool {
-    let unit = wordcraft_geom::Unit::default();
+    let unit = crate::options::unit();
     fn len(v: &mut f32, unit: wordcraft_geom::Unit) -> egui::DragValue<'_> {
         egui::DragValue::new(v).speed(0.01).range(-10.0..=22.0).suffix(unit.suffix()).max_decimals(2)
     }
@@ -310,7 +310,7 @@ fn preview(ui: &mut Ui, f: &ListForm) {
     let p = ui.painter_at(rect);
     p.rect_filled(rect, 2.0, egui::Color32::WHITE);
     p.rect_stroke(rect, 2.0, egui::Stroke::new(1.0, t.border_strong), egui::StrokeKind::Inside);
-    let k = wordcraft_geom::Unit::default().pt_per_unit();
+    let k = crate::options::unit().pt_per_unit();
     // Positions in points, scaled so 4.5 inches fit.
     let scale = (rect.width() - 16.0) / 324.0;
     let x_of = |v: f32| rect.left() + 8.0 + (v * k * scale).clamp(0.0, rect.width() - 40.0);
@@ -416,8 +416,10 @@ fn choice(ui: &mut Ui, id: &str, value: &mut String, options: &[(&str, &str)]) {
 /// A colour: `none_label` (by author, or `auto` when given) or a colour from the grid. `value` is
 /// hex.
 fn color(ui: &mut Ui, theme: &[wordcraft_doc::Rgb], value: &mut String, none_label: &str, auto: Option<wordcraft_doc::Rgb>) {
-    let c = wordcraft_doc::Rgb::parse(value);
     ui.horizontal(|ui| {
+        let id = ui.id().with("colorField");
+        crate::colors::take_field(ui.ctx(), id, value);
+        let c = wordcraft_doc::Rgb::parse(value);
         let (r, _) = ui.allocate_exact_size(vec2(16.0, 16.0), Sense::hover());
         let t = Tokens::get(ui.ctx());
         match c.or(auto) {
@@ -440,10 +442,7 @@ fn color(ui: &mut Ui, theme: &[wordcraft_doc::Rgb], value: &mut String, none_lab
                 value.clear();
                 ui.close();
             }
-            if let Some(hex) = crate::widgets::color_grid(ui, theme) {
-                *value = hex;
-                ui.close();
-            }
+            crate::colors::field_menu(ui, theme, id, value);
         });
     });
 }
diff --git a/crates/ui-egui/src/dialogs_para.rs b/crates/ui-egui/src/dialogs_para.rs
index cfb3ce1baa..081beb9580 100644
--- a/crates/ui-egui/src/dialogs_para.rs
+++ b/crates/ui-egui/src/dialogs_para.rs
@@ -15,7 +15,7 @@ use crate::theme::{Tokens, semibold};
 const SAME_POS: f32 = 0.5;
 
 fn unit() -> wordcraft_geom::Unit {
-    wordcraft_geom::Unit::default()
+    crate::options::unit()
 }
 
 /// The Tabs dialog's fields. Positions in `stops` and `cleared` are points; `pos` and
diff --git a/crates/ui-egui/src/dialogs_refs.rs b/crates/ui-egui/src/dialogs_refs.rs
new file mode 100644
index 0000000000..b161ae46e1
--- /dev/null
+++ b/crates/ui-egui/src/dialogs_refs.rs
@@ -0,0 +1,1183 @@
+//! References dialogs (#402): Caption (with New Label and Numbering), Index and Mark Index Entry,
+//! Custom Table of Contents (with Options and the TOC styles), and the Source Manager with
+//! Create / Edit Source. Each fills a form from the session and ends in a command
+//! (`references.caption`, `references.index`, `references.markEntry`, `references.toc`,
+//! `references.sources`, `references.citation`), so agents get the same result without the
+//! dialog. Shown through [`crate::dialogs::Dialog::Refs`].
+
+use egui::{Sense, Ui, vec2};
+use serde::Serialize;
+use serde_json::{Value, json};
+use wordcraft_doc::{Block, Source, StyleKind};
+use wordcraft_engine::cmd::references::FieldCode;
+
+use crate::WordApp;
+use crate::dialogs::{Dialog, buttons};
+use crate::theme::{Tokens, semibold};
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(tag = "refs", rename_all = "camelCase")]
+pub enum RefsDialog {
+    Caption(CaptionForm),
+    /// Caption › Numbering…; `was` comes back on Cancel.
+    CaptionNumbering {
+        form: CaptionForm,
+        #[serde(skip)]
+        was: Box<CaptionForm>,
+    },
+    /// Caption › New Label….
+    NewLabel(CaptionForm),
+    Index(IndexForm),
+    MarkEntry(MarkForm),
+    Toc(TocForm),
+    /// Table of Contents › Options…; `was` comes back on Cancel.
+    TocOptions {
+        form: TocForm,
+        #[serde(skip)]
+        was: Box<TocForm>,
+    },
+    /// Table of Contents › Modify…: the TOC 1–9 styles.
+    TocStyles {
+        form: TocForm,
+        level: u8,
+    },
+    Sources {
+        selected: Option<usize>,
+    },
+    Source(Box<SourceForm>),
+}
+
+impl RefsDialog {
+    pub fn name(&self) -> &'static str {
+        match self {
+            RefsDialog::Caption(_) => "caption",
+            RefsDialog::CaptionNumbering { .. } => "captionNumbering",
+            RefsDialog::NewLabel(_) => "newLabel",
+            RefsDialog::Index(_) => "index",
+            RefsDialog::MarkEntry(_) => "markEntry",
+            RefsDialog::Toc(_) => "toc",
+            RefsDialog::TocOptions { .. } => "tocOptions",
+            RefsDialog::TocStyles { .. } => "tocStyles",
+            RefsDialog::Sources { .. } => "sourceManager",
+            RefsDialog::Source(f) if f.edit => "editSource",
+            RefsDialog::Source(_) => "createSource",
+        }
+    }
+
+    /// The window title (English; the caller translates it).
+    pub fn title(&self) -> &'static str {
+        match self {
+            RefsDialog::Caption(_) => "Caption",
+            RefsDialog::CaptionNumbering { .. } => "Caption Numbering",
+            RefsDialog::NewLabel(_) => "New Label",
+            RefsDialog::Index(_) => "Index",
+            RefsDialog::MarkEntry(_) => "Mark Index Entry",
+            RefsDialog::Toc(_) => "Table of Contents",
+            RefsDialog::TocOptions { .. } => "Table of Contents Options",
+            RefsDialog::TocStyles { .. } => "Table of Contents Styles",
+            RefsDialog::Sources { .. } => "Source Manager",
+            RefsDialog::Source(f) if f.edit => "Edit Source",
+            RefsDialog::Source(_) => "Create Source",
+        }
+    }
+}
+
+/// The dialog `ui.dialog` opens by `name`: `caption`, `index`, `markEntry`, `toc`,
+/// `sourceManager` or `createSource` (which inserts a citation of the new source).
+pub fn open(name: &str, app: &WordApp) -> Option<RefsDialog> {
+    Some(match name {
+        "caption" => RefsDialog::Caption(CaptionForm::read(app)),
+        "index" => RefsDialog::Index(IndexForm::read(app)),
+        "markEntry" => RefsDialog::MarkEntry(MarkForm::read(app)),
+        "toc" => RefsDialog::Toc(TocForm::read(app)),
+        "sourceManager" => RefsDialog::Sources { selected: None },
+        "createSource" => RefsDialog::Source(Box::new(SourceForm::new(true, false))),
+        _ => return None,
+    })
+}
+
+/// Draws the dialog; returns true to close it.
+pub fn body(app: &mut WordApp, ui: &mut Ui, d: &mut RefsDialog) -> bool {
+    let next = match d {
+        RefsDialog::Caption(f) => caption_ui(app, ui, f),
+        RefsDialog::CaptionNumbering { form, was } => numbering_ui(ui, form, was),
+        RefsDialog::NewLabel(f) => new_label_ui(app, ui, f),
+        RefsDialog::Index(f) => index_ui(app, ui, f),
+        RefsDialog::MarkEntry(f) => mark_ui(app, ui, f),
+        RefsDialog::Toc(f) => toc_ui(app, ui, f),
+        RefsDialog::TocOptions { form, was } => toc_options_ui(app, ui, form, was),
+        RefsDialog::TocStyles { form, level } => toc_styles_ui(app, ui, form, level),
+        RefsDialog::Sources { selected } => sources_ui(app, ui, selected),
+        RefsDialog::Source(f) => source_ui(app, ui, f),
+    };
+    match next {
+        Next::Stay => false,
+        Next::Close => true,
+        Next::Go(n) => {
+            *d = *n;
+            false
+        }
+    }
+}
+
+fn go(d: RefsDialog) -> Next {
+    Next::Go(Box::new(d))
+}
+
+/// What a dialog does after a frame.
+enum Next {
+    Stay,
+    Close,
+    Go(Box<RefsDialog>),
+}
+
+fn heading(ui: &mut Ui, s: &str) {
+    ui.add_space(4.0);
+    ui.label(egui::RichText::new(tl!(s)).font(semibold(12.5)));
+}
+
+/// A choice from `options` ((value, label)) in a drop-down.
+fn choice<T: PartialEq + Clone>(ui: &mut Ui, id: &str, value: &mut T, options: &[(T, &str)]) {
+    let label = options.iter().find(|(v, _)| v == value).map(|(_, l)| tl!(l).to_string()).unwrap_or_default();
+    egui::ComboBox::from_id_salt(id).selected_text(label).width(150.0).show_ui(ui, |ui| {
+        for (v, l) in options {
+            ui.selectable_value(value, v.clone(), tl!(l));
+        }
+    });
+}
+
+const LEADERS: [(&str, &str); 4] = [("none", "(none)"), ("dot", "........"), ("hyphen", "--------"), ("underscore", "________")];
+
+fn leader_char(l: &str) -> Option<char> {
+    match l {
+        "dot" => Some('.'),
+        "hyphen" => Some('-'),
+        "underscore" => Some('_'),
+        _ => None,
+    }
+}
+
+/// Sample lines on a white card: (indent level, text, page or empty), with `leader` filling up
+/// to right-aligned page numbers (or the page right after the text).
+fn sample(ui: &mut Ui, lines: &[(usize, String, String)], right: bool, leader: Option<char>) {
+    let t = Tokens::get(ui.ctx());
+    let row = 17.0;
+    let (rect, _) = ui.allocate_exact_size(vec2(260.0, row * lines.len().max(1) as f32 + 10.0), Sense::hover());
+    let p = ui.painter_at(rect);
+    p.rect_filled(rect, 2.0, egui::Color32::WHITE);
+    p.rect_stroke(rect, 2.0, egui::Stroke::new(1.0, t.border_strong), egui::StrokeKind::Inside);
+    let font = egui::FontId::proportional(11.0);
+    let ink = egui::Color32::BLACK;
+    for (i, (level, text, page)) in lines.iter().enumerate() {
+        let y = rect.top() + 5.0 + row * i as f32;
+        let x = rect.left() + 8.0 + 12.0 * *level as f32;
+        let g = p.layout_no_wrap(text.clone(), font.clone(), ink);
+        let w = g.size().x;
+        p.galley(egui::pos2(x, y), g, ink);
+        if page.is_empty() {
+            continue;
+        }
+        let pg = p.layout_no_wrap(page.clone(), font.clone(), ink);
+        let pw = pg.size().x;
+        let px = if right { rect.right() - 8.0 - pw } else { x + w + 4.0 };
+        p.galley(egui::pos2(px, y), pg, ink);
+        if right && let Some(c) = leader {
+            let dots = p.layout_no_wrap(c.to_string(), font.clone(), egui::Color32::from_gray(90));
+            let step = dots.size().x.max(2.0);
+            let mut dx = x + w + 4.0;
+            while dx + step < px - 3.0 {
+                p.galley(egui::pos2(dx, y), dots.clone(), egui::Color32::from_gray(90));
+                dx += step;
+            }
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------------------------
+// Caption
+
+/// Labels every document has.
+const BUILT_IN_LABELS: [&str; 3] = ["Equation", "Figure", "Table"];
+
+const NUMBER_FORMATS: [(&str, &str); 5] =
+    [("ARABIC", "1, 2, 3, …"), ("alphabetic", "a, b, c, …"), ("ALPHABETIC", "A, B, C, …"), ("roman", "i, ii, iii, …"), ("ROMAN", "I, II, III, …")];
+
+const SEPARATORS: [(&str, &str); 5] =
+    [("-", "- (hyphen)"), (".", ". (period)"), (":", ": (colon)"), ("\u{2014}", "\u{2014} (em dash)"), ("\u{2013}", "\u{2013} (en dash)")];
+
+/// The Caption dialog's fields.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CaptionForm {
+    pub label: String,
+    /// Built-in labels and the user's own (kept with the interface settings, like Word's
+    /// Normal template keeps them).
+    pub labels: Vec<String>,
+    pub text: String,
+    /// `below` or `above`.
+    pub position: String,
+    pub exclude_label: bool,
+    /// `\*` format: `ARABIC`, `alphabetic`, `ALPHABETIC`, `roman`, `ROMAN`.
+    pub format: String,
+    pub chapter: bool,
+    /// Heading level that starts a chapter (1–9).
+    pub chapter_level: u8,
+    pub separator: String,
+    /// New Label's text.
+    pub new_label: String,
+}
+
+impl CaptionForm {
+    pub fn read(app: &WordApp) -> CaptionForm {
+        let mut labels: Vec<String> = BUILT_IN_LABELS.iter().map(|l| l.to_string()).collect();
+        for l in &app.ui.caption_labels {
+            if !labels.contains(l) {
+                labels.push(l.clone());
+            }
+        }
+        // In a table the caption is for the table.
+        let in_table = app.session.sel.focus.path.depth() > 0
+            && app
+                .session
+                .doc
+                .body
+                .get(app.session.sel.focus.path.0.first().copied().unwrap_or(0) as usize)
+                .is_some_and(|b| matches!(&**b, Block::Table(_)));
+        CaptionForm {
+            label: if in_table { "Table" } else { "Figure" }.into(),
+            labels,
+            text: String::new(),
+            position: "below".into(),
+            exclude_label: false,
+            format: "ARABIC".into(),
+            chapter: false,
+            chapter_level: 1,
+            separator: "-".into(),
+            new_label: String::new(),
+        }
+    }
+
+    /// The number as it will show (`Figure 1-A`).
+    pub fn preview(&self) -> String {
+        let n = match self.format.as_str() {
+            "alphabetic" => "a",
+            "ALPHABETIC" => "A",
+            "roman" => "i",
+            "ROMAN" => "I",
+            _ => "1",
+        };
+        let chapter = if self.chapter { format!("1{}", self.separator) } else { String::new() };
+        let label = if self.exclude_label { String::new() } else { format!("{} ", self.label) };
+        format!("{label}{chapter}{n}")
+    }
+
+    /// `references.caption` parameters.
+    pub fn params(&self) -> Value {
+        let mut v = json!({
+            "label": self.label,
+            "text": self.text.trim(),
+            "position": self.position,
+            "excludeLabel": self.exclude_label,
+            "format": self.format,
+        });
+        if self.chapter {
+            v["chapter"] = json!(self.chapter_level);
+            v["separator"] = json!(self.separator);
+        }
+        v
+    }
+}
+
+fn caption_ui(app: &mut WordApp, ui: &mut Ui, f: &mut CaptionForm) -> Next {
+    ui.label(tl!("Caption:"));
+    ui.horizontal(|ui| {
+        ui.label(f.preview());
+        ui.add(egui::TextEdit::singleline(&mut f.text).desired_width(220.0).hint_text(tl!("Caption text")));
+    });
+    ui.add_space(6.0);
+    let mut then = None;
+    egui::Grid::new("cap_opts").num_columns(2).spacing(vec2(10.0, 6.0)).show(ui, |ui| {
+        ui.label(tl!("Label:"));
+        let labels: Vec<(String, &str)> = f.labels.iter().map(|l| (l.clone(), l.as_str())).collect();
+        egui::ComboBox::from_id_salt("cap_label").selected_text(tl!(&f.label)).width(150.0).show_ui(ui, |ui| {
+            for (v, l) in &labels {
+                ui.selectable_value(&mut f.label, v.clone(), tl!(l));
+            }
+        });
+        ui.end_row();
+        ui.label(tl!("Position:"));
+        choice(ui, "cap_pos", &mut f.position, &[("below".to_string(), "Below the item"), ("above".to_string(), "Above the item")]);
+        ui.end_row();
+    });
+    ui.checkbox(&mut f.exclude_label, tl!("Leave the label out of the caption"));
+    ui.add_space(4.0);
+    ui.horizontal(|ui| {
+        if ui.button(tl!("New Label…")).clicked() {
+            let mut n = f.clone();
+            n.new_label.clear();
+            then = Some(RefsDialog::NewLabel(n));
+        }
+        let custom = !BUILT_IN_LABELS.contains(&f.label.as_str());
+        if ui.add_enabled(custom, egui::Button::new(tl!("Delete Label"))).clicked() {
+            app.ui.caption_labels.retain(|l| *l != f.label);
+            f.labels.retain(|l| *l != f.label);
+            f.label = "Figure".into();
+        }
+        if ui.button(tl!("Numbering…")).clicked() {
+            then = Some(RefsDialog::CaptionNumbering { was: Box::new(f.clone()), form: f.clone() });
+        }
+    });
+    if let Some(g) = then {
+        return go(g);
+    }
+    let (ok, cancel) = buttons(ui, tl!("OK"));
+    if ok && let Err(e) = app.run("references.caption", f.params()) {
+        app.status(e);
+    }
+    if ok || cancel { Next::Close } else { Next::Stay }
+}
+
+fn numbering_ui(ui: &mut Ui, f: &mut CaptionForm, was: &CaptionForm) -> Next {
+    egui::Grid::new("cap_num").num_columns(2).spacing(vec2(10.0, 6.0)).show(ui, |ui| {
+        ui.label(tl!("Format:"));
+        let opts: Vec<(String, &str)> = NUMBER_FORMATS.iter().map(|(v, l)| (v.to_string(), *l)).collect();
+        choice(ui, "cap_fmt", &mut f.format, &opts);
+        ui.end_row();
+    });
+    ui.checkbox(&mut f.chapter, tl!("Add the chapter number"));
+    ui.add_enabled_ui(f.chapter, |ui| {
+        egui::Grid::new("cap_chap").num_columns(2).spacing(vec2(10.0, 6.0)).show(ui, |ui| {
+            ui.label(tl!("Chapters begin at:"));
+            let opts: Vec<(u8, String)> = (1..=9u8).map(|l| (l, crate::i18n::fmt(tl!("Heading {n}"), &[("n", &l.to_string())]))).collect();
+            let shown = opts.iter().find(|(l, _)| *l == f.chapter_level).map(|(_, s)| s.clone()).unwrap_or_default();
+            egui::ComboBox::from_id_salt("cap_level").selected_text(shown).width(150.0).show_ui(ui, |ui| {
+                for (l, s) in &opts {
+                    ui.selectable_value(&mut f.chapter_level, *l, s);
+                }
+            });
+            ui.end_row();
+            ui.label(tl!("Separator:"));
+            let opts: Vec<(String, &str)> = SEPARATORS.iter().map(|(v, l)| (v.to_string(), *l)).collect();
+            choice(ui, "cap_sep", &mut f.separator, &opts);
+            ui.end_row();
+        });
+    });
+    ui.add_space(4.0);
+    ui.label(crate::i18n::fmt(tl!("Example: {sample}"), &[("sample", &f.preview())]));
+    let (ok, cancel) = buttons(ui, tl!("OK"));
+    if ok {
+        return go(RefsDialog::Caption(f.clone()));
+    }
+    if cancel {
+        return go(RefsDialog::Caption(was.clone()));
+    }
+    Next::Stay
+}
+
+fn new_label_ui(app: &mut WordApp, ui: &mut Ui, f: &mut CaptionForm) -> Next {
+    ui.label(tl!("Label:"));
+    let r = ui.add(egui::TextEdit::singleline(&mut f.new_label).desired_width(260.0));
+    r.request_focus();
+    let (ok, cancel) = buttons(ui, tl!("OK"));
+    let name: String = f.new_label.chars().filter(|c| !matches!(c, '"' | '\\') && !c.is_control()).take(40).collect::<String>().trim().to_string();
+    if ok && !name.is_empty() {
+        if !f.labels.contains(&name) {
+            f.labels.push(name.clone());
+        }
+        if !BUILT_IN_LABELS.contains(&name.as_str()) && !app.ui.caption_labels.contains(&name) {
+            app.ui.caption_labels.push(name.clone());
+        }
+        f.label = name;
+    }
+    if ok || cancel { go(RefsDialog::Caption(f.clone())) } else { Next::Stay }
+}
+
+// ---------------------------------------------------------------------------------------------
+// Index and Mark Index Entry
+
+/// The Index dialog's fields.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct IndexForm {
+    /// `indented` or `runIn`.
+    pub kind: String,
+    pub columns: u32,
+    pub right_align: bool,
+    pub leader: String,
+    pub headings: bool,
+}
+
+/// The first field in the body whose name is `name`.
+fn body_field(app: &WordApp, name: &str) -> Option<FieldCode> {
+    app.session.doc.body.iter().filter_map(|b| b.as_para()).flat_map(|p| p.objects.iter()).find_map(|o| match o {
+        wordcraft_doc::InlineObject::Field { instr, .. } => {
+            Some(FieldCode::parse(instr)).filter(|f| f.name == name && (name != "TOC" || !f.has('c')))
+        }
+        _ => None,
+    })
+}
+
+impl IndexForm {
+    /// The index in the document, or Word's defaults for a new one (two columns).
+    pub fn read(app: &WordApp) -> IndexForm {
+        match body_field(app, "INDEX") {
+            Some(f) => IndexForm {
+                kind: if f.has('r') { "runIn" } else { "indented" }.into(),
+                columns: f.arg('c').and_then(|c| c.trim().parse().ok()).unwrap_or(1).clamp(1, 4),
+                right_align: f.arg('e').is_some_and(|e| e.contains('\t')),
+                leader: "dot".into(),
+                headings: f.has('h'),
+            },
+            None => IndexForm { kind: "indented".into(), columns: 2, right_align: false, leader: "dot".into(), headings: true },
+        }
+    }
+
+    /// `references.index` parameters.
+    pub fn params(&self) -> Value {
+        json!({"type": self.kind, "columns": self.columns, "rightAlign": self.right_align, "tabLeader": self.leader, "headings": self.headings})
+    }
+}
+
+fn index_ui(app: &mut WordApp, ui: &mut Ui, f: &mut IndexForm) -> Next {
+    let page = |p: &str| p.to_string();
+    let lines: Vec<(usize, String, String)> = {
+        let mut v = Vec::new();
+        if f.headings {
+            v.push((0, "A".to_string(), String::new()));
+        }
+        if f.kind == "runIn" {
+            v.push((0, format!("{}: {}, 4; {}", tl!("Atmosphere"), tl!("Ionosphere"), tl!("Mesosphere")), page("3")));
+        } else {
+            v.push((0, tl!("Atmosphere").to_string(), page("1")));
+            v.push((1, tl!("Ionosphere").to_string(), page("3")));
+            v.push((1, tl!("Mesosphere").to_string(), page("4")));
+        }
+        v
+    };
+    sample(ui, &lines, f.right_align, leader_char(&f.leader));
+    ui.add_space(6.0);
+    egui::Grid::new("idx").num_columns(2).spacing(vec2(10.0, 6.0)).show(ui, |ui| {
+        ui.label(tl!("Type:"));
+        ui.horizontal(|ui| {
+            ui.radio_value(&mut f.kind, "indented".to_string(), tl!("Indented"));
+            ui.radio_value(&mut f.kind, "runIn".to_string(), tl!("Run-in"));
+        });
+        ui.end_row();
+        ui.label(tl!("Columns:"));
+        ui.add(egui::DragValue::new(&mut f.columns).range(1..=4));
+        ui.end_row();
+        ui.label("");
+        ui.checkbox(&mut f.right_align, tl!("Page numbers at the right margin"));
+        ui.end_row();
+        ui.label(tl!("Tab leader:"));
+        ui.add_enabled_ui(f.right_align, |ui| {
+            let opts: Vec<(String, &str)> = LEADERS.iter().map(|(v, l)| (v.to_string(), *l)).collect();
+            choice(ui, "idx_leader", &mut f.leader, &opts);
+        });
+        ui.end_row();
+        ui.label("");
+        ui.checkbox(&mut f.headings, tl!("Letter headings"));
+        ui.end_row();
+    });
+    ui.add_space(4.0);
+    if ui.button(tl!("Mark Entry…")).clicked() {
+        return go(RefsDialog::MarkEntry(MarkForm::read(app)));
+    }
+    let (ok, cancel) = buttons(ui, tl!("OK"));
+    if ok && let Err(e) = app.run("references.index", f.params()) {
+        app.status(e);
+    }
+    if ok || cancel { Next::Close } else { Next::Stay }
+}
+
+/// The Mark Index Entry dialog's fields.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct MarkForm {
+    pub entry: String,
+    pub subentry: String,
+    /// `page` (current page), `see` (cross-reference) or `range` (page range bookmark).
+    pub option: String,
+    pub see: String,
+    pub bookmark: String,
+    pub bookmarks: Vec<String>,
+    pub bold: bool,
+    pub italic: bool,
+    pub message: String,
+}
+
+impl MarkForm {
+    pub fn read(app: &WordApp) -> MarkForm {
+        let bookmarks: Vec<String> = app.session.doc.bookmarks().into_iter().map(|(n, _)| n).filter(|n| !n.starts_with('_')).collect();
+        MarkForm {
+            entry: app.session.selected_text().trim().to_string(),
+            subentry: String::new(),
+            option: "page".into(),
+            see: format!("{} ", tl!("See")),
+            bookmark: bookmarks.first().cloned().unwrap_or_default(),
+            bookmarks,
+            bold: false,
+            italic: false,
+            message: String::new(),
+        }
+    }
+
+    /// `references.markEntry` parameters (`all` for Mark All).
+    pub fn params(&self, all: bool) -> Value {
+        let mut v = json!({"entry": self.entry.trim(), "subentry": self.subentry.trim(), "bold": self.bold, "italic": self.italic, "all": all});
+        match self.option.as_str() {
+            "see" => v["crossReference"] = json!(self.see.trim()),
+            "range" => v["bookmark"] = json!(self.bookmark),
+            _ => {}
+        }
+        if all {
+            v["text"] = json!(self.entry.trim());
+        }
+        v
+    }
+}
+
+fn mark_ui(app: &mut WordApp, ui: &mut Ui, f: &mut MarkForm) -> Next {
+    heading(ui, "Index");
+    egui::Grid::new("xe").num_columns(2).spacing(vec2(10.0, 6.0)).show(ui, |ui| {
+        ui.label(tl!("Main entry:"));
+        ui.add(egui::TextEdit::singleline(&mut f.entry).desired_width(220.0));
+        ui.end_row();
+        ui.label(tl!("Subentry:"));
+        ui.add(egui::TextEdit::singleline(&mut f.subentry).desired_width(220.0));
+        ui.end_row();
+    });
+    heading(ui, "Options");
+    ui.horizontal(|ui| {
+        ui.radio_value(&mut f.option, "see".to_string(), tl!("Cross-reference:"));
+        ui.add_enabled(f.option == "see", egui::TextEdit::singleline(&mut f.see).desired_width(160.0));
+    });
+    ui.radio_value(&mut f.option, "page".to_string(), tl!("This page"));
+    ui.horizontal(|ui| {
+        ui.add_enabled_ui(!f.bookmarks.is_empty(), |ui| {
+            ui.radio_value(&mut f.option, "range".to_string(), tl!("Pages of bookmark:"));
+        });
+        ui.add_enabled_ui(f.option == "range", |ui| {
+            let opts: Vec<(String, &str)> = f.bookmarks.iter().map(|b| (b.clone(), b.as_str())).collect();
+            egui::ComboBox::from_id_salt("xe_bm").selected_text(f.bookmark.clone()).width(140.0).show_ui(ui, |ui| {
+                for (v, l) in &opts {
+                    ui.selectable_value(&mut f.bookmark, v.clone(), *l);
+                }
+            });
+        });
+    });
+    heading(ui, "Page number style");
+    ui.horizontal(|ui| {
+        ui.checkbox(&mut f.bold, tl!("Bold"));
+        ui.checkbox(&mut f.italic, tl!("Italic"));
+    });
+    if !f.message.is_empty() {
+        ui.label(egui::RichText::new(&f.message).small());
+    }
+    let mut close = false;
+    ui.add_space(8.0);
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if ui.button(tl!("Close")).clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+                close = true;
+            }
+            let can = !f.entry.trim().is_empty();
+            if ui.add_enabled(can, egui::Button::new(tl!("Mark All"))).clicked() {
+                f.message = match app.run("references.markEntry", f.params(true)) {
+                    Ok(v) => {
+                        crate::i18n::fmt(tl!("{n} entries marked."), &[("n", &v.get("marked").and_then(Value::as_u64).unwrap_or(0).to_string())])
+                    }
+                    Err(e) => e,
+                };
+            }
+            if ui
+                .add_enabled(can, egui::Button::new(egui::RichText::new(tl!("Mark")).color(egui::Color32::WHITE)).fill(crate::theme::APP_COLOR))
+                .clicked()
+            {
+                f.message = match app.run("references.markEntry", f.params(false)) {
+                    Ok(_) => tl!("Entry marked.").to_string(),
+                    Err(e) => e,
+                };
+            }
+        });
+    });
+    if close { Next::Close } else { Next::Stay }
+}
+
+// ---------------------------------------------------------------------------------------------
+// Table of Contents
+
+/// The Custom Table of Contents dialog's fields (with its Options).
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct TocForm {
+    pub page_numbers: bool,
+    pub right_align: bool,
+    pub leader: String,
+    pub hyperlinks: bool,
+    pub levels: u8,
+    /// Options: heading styles (`\o`), outline levels (`\u`), TC fields (`\f`).
+    pub heading_styles: bool,
+    pub outline_levels: bool,
+    pub tc_fields: bool,
+    /// Options: other paragraph styles with a TOC level (0 = not in the table), by style name.
+    pub style_levels: Vec<(String, u8)>,
+}
+
+impl TocForm {
+    /// The table in the document, or the defaults for a new one.
+    pub fn read(app: &WordApp) -> TocForm {
+        let f = body_field(app, "TOC").unwrap_or_else(|| FieldCode::parse(r#"TOC \o "1-3" \h \z \u"#));
+        let levels = f.arg('o').and_then(wordcraft_engine::cmd::references::level_range).map_or(3, |r| r.1);
+        let listed: Vec<(String, u8)> = f
+            .arg('t')
+            .map(|t| {
+                let parts: Vec<&str> = t.split(',').map(str::trim).collect();
+                parts.chunks(2).filter_map(|c| Some((c.first()?.to_string(), c.get(1)?.parse::<u8>().ok()?.clamp(1, 9)))).collect()
+            })
+            .unwrap_or_default();
+        let style_levels = app
+            .session
+            .doc
+            .styles
+            .styles
+            .iter()
+            .filter(|s| s.kind == StyleKind::Paragraph && !s.hidden && !s.id.starts_with("Heading") && !s.id.starts_with("TOC"))
+            .map(|s| (s.name.clone(), listed.iter().find(|(n, _)| n.eq_ignore_ascii_case(&s.name)).map_or(0, |(_, l)| *l)))
+            .collect();
+        // Right-aligned page numbers: no `\p` separator, or a tab one.
+        let leader = app
+            .session
+            .doc
+            .body
+            .iter()
+            .filter_map(|b| b.as_para())
+            .find(|p| p.props.style.as_deref().is_some_and(|s| s.starts_with("TOC") && s != "TOCHeading"))
+            .and_then(|p| p.props.tabs.as_ref()?.last().map(|t| t.leader));
+        TocForm {
+            page_numbers: !f.has('n'),
+            right_align: f.arg('p').is_none_or(|p| p.contains('\t')),
+            leader: match leader {
+                Some(wordcraft_doc::props::TabLeader::None) => "none",
+                Some(wordcraft_doc::props::TabLeader::Hyphen) => "hyphen",
+                Some(wordcraft_doc::props::TabLeader::Underscore) => "underscore",
+                _ => "dot",
+            }
+            .into(),
+            hyperlinks: f.has('h'),
+            levels: levels.clamp(1, 9),
+            heading_styles: f.has('o'),
+            outline_levels: f.has('u'),
+            tc_fields: f.has('f'),
+            style_levels,
+        }
+    }
+
+    /// `references.toc` parameters.
+    pub fn params(&self) -> Value {
+        let styles: serde_json::Map<String, Value> = self.style_levels.iter().filter(|(_, l)| *l > 0).map(|(n, l)| (n.clone(), json!(l))).collect();
+        json!({
+            "levels": self.levels,
+            "pageNumbers": self.page_numbers,
+            "rightAlign": self.right_align,
+            "tabLeader": self.leader,
+            "hyperlinks": self.hyperlinks,
+            "headingStyles": self.heading_styles,
+            "outlineLevels": self.outline_levels,
+            "tcFields": self.tc_fields,
+            "styleLevels": styles,
+        })
+    }
+}
+
+fn toc_ui(app: &mut WordApp, ui: &mut Ui, f: &mut TocForm) -> Next {
+    let lines: Vec<(usize, String, String)> = (1..=f.levels.min(3))
+        .map(|l| {
+            let name = crate::i18n::fmt(tl!("Heading {n}"), &[("n", &l.to_string())]);
+            (l as usize - 1, name, if f.page_numbers { (l * 2 - 1).to_string() } else { String::new() })
+        })
+        .collect();
+    sample(ui, &lines, f.right_align, leader_char(&f.leader));
+    ui.add_space(6.0);
+    ui.checkbox(&mut f.page_numbers, tl!("Include page numbers"));
+    ui.add_enabled_ui(f.page_numbers, |ui| {
+        ui.checkbox(&mut f.right_align, tl!("Page numbers at the right margin"));
+        ui.horizontal(|ui| {
+            ui.label(tl!("Tab leader:"));
+            ui.add_enabled_ui(f.right_align, |ui| {
+                let opts: Vec<(String, &str)> = LEADERS.iter().map(|(v, l)| (v.to_string(), *l)).collect();
+                choice(ui, "toc_leader", &mut f.leader, &opts);
+            });
+        });
+    });
+    ui.checkbox(&mut f.hyperlinks, tl!("Link entries to their headings"));
+    ui.horizontal(|ui| {
+        ui.label(tl!("Levels:"));
+        ui.add(egui::DragValue::new(&mut f.levels).range(1..=9));
+    });
+    ui.add_space(4.0);
+    let mut then = None;
+    ui.horizontal(|ui| {
+        if ui.button(tl!("Options…")).clicked() {
+            then = Some(RefsDialog::TocOptions { was: Box::new(f.clone()), form: f.clone() });
+        }
+        if ui.button(tl!("Modify…")).clicked() {
+            then = Some(RefsDialog::TocStyles { form: f.clone(), level: 1 });
+        }
+    });
+    if let Some(g) = then {
+        return go(g);
+    }
+    let (ok, cancel) = buttons(ui, tl!("OK"));
+    if ok && let Err(e) = app.run("references.toc", f.params()) {
+        app.status(e);
+    }
+    if ok || cancel { Next::Close } else { Next::Stay }
+}
+
+fn toc_options_ui(_app: &mut WordApp, ui: &mut Ui, f: &mut TocForm, was: &TocForm) -> Next {
+    heading(ui, "Collect entries from:");
+    ui.checkbox(&mut f.heading_styles, crate::i18n::fmt(tl!("Heading styles (levels 1–{n})"), &[("n", &f.levels.to_string())]));
+    ui.label(tl!("Other styles and their TOC level:"));
+    egui::ScrollArea::vertical().max_height(180.0).show(ui, |ui| {
+        egui::Grid::new("toc_styles").num_columns(2).spacing(vec2(10.0, 3.0)).show(ui, |ui| {
+            for (name, level) in f.style_levels.iter_mut() {
+                ui.label(name.as_str());
+                ui.add(egui::DragValue::new(level).range(0..=9).custom_formatter(|v, _| if v < 0.5 { String::new() } else { format!("{v:.0}") }));
+                ui.end_row();
+            }
+        });
+    });
+    ui.checkbox(&mut f.outline_levels, tl!("Outline levels"));
+    ui.checkbox(&mut f.tc_fields, tl!("TC entry fields"));
+    ui.add_space(4.0);
+    if ui.button(tl!("Reset")).clicked() {
+        f.heading_styles = true;
+        f.outline_levels = true;
+        f.tc_fields = false;
+        for (_, l) in f.style_levels.iter_mut() {
+            *l = 0;
+        }
+    }
+    let (ok, cancel) = buttons(ui, tl!("OK"));
+    if ok {
+        return go(RefsDialog::Toc(f.clone()));
+    }
+    if cancel {
+        return go(RefsDialog::Toc(was.clone()));
+    }
+    Next::Stay
+}
+
+/// Modify… in Table of Contents: pick a TOC level style and edit it in Modify Style, which
+/// comes back here when it closes.
+fn toc_styles_ui(app: &mut WordApp, ui: &mut Ui, f: &mut TocForm, level: &mut u8) -> Next {
+    ui.label(tl!("Styles:"));
+    egui::ScrollArea::vertical().max_height(200.0).show(ui, |ui| {
+        for l in 1..=9u8 {
+            let name = app.session.doc.styles.get(&format!("TOC{l}")).map(|s| s.name.clone()).unwrap_or_else(|| format!("TOC {l}"));
+            ui.selectable_value(level, l, name);
+        }
+    });
+    ui.add_space(6.0);
+    if ui.button(tl!("Modify…")).clicked()
+        && let Some(mut d) = Dialog::modify_style(app, &format!("TOC{level}"))
+    {
+        if let Dialog::ModifyStyle { resume, .. } = &mut d {
+            *resume = Some(Box::new(Dialog::Refs(Box::new(RefsDialog::TocStyles { form: f.clone(), level: *level }))));
+        }
+        app.dialog = Some(d);
+        return Next::Close;
+    }
+    let (ok, cancel) = buttons(ui, tl!("OK"));
+    if ok || cancel { go(RefsDialog::Toc(f.clone())) } else { Next::Stay }
+}
+
+// ---------------------------------------------------------------------------------------------
+// Sources
+
+/// Source types with their fields: (kind, label, recommended fields). A field is (key, label).
+const SOURCE_TYPES: [(&str, &str, &[(&str, &str)]); 9] = [
+    ("book", "Book", &[("author", "Author"), ("title", "Title"), ("year", "Year"), ("city", "City"), ("publisher", "Publisher")]),
+    (
+        "bookSection",
+        "Chapter in a book",
+        &[
+            ("author", "Author"),
+            ("title", "Title"),
+            ("journal", "Book title"),
+            ("year", "Year"),
+            ("pages", "Pages"),
+            ("city", "City"),
+            ("publisher", "Publisher"),
+        ],
+    ),
+    (
+        "article",
+        "Journal article",
+        &[("author", "Author"), ("title", "Title"), ("journal", "Journal"), ("year", "Year"), ("volume", "Volume"), ("pages", "Pages")],
+    ),
+    (
+        "periodical",
+        "Magazine or newspaper article",
+        &[
+            ("author", "Author"),
+            ("title", "Title"),
+            ("journal", "Periodical"),
+            ("year", "Year"),
+            ("month", "Month"),
+            ("day", "Day"),
+            ("pages", "Pages"),
+        ],
+    ),
+    (
+        "conference",
+        "Conference paper",
+        &[
+            ("author", "Author"),
+            ("title", "Title"),
+            ("journal", "Conference"),
+            ("year", "Year"),
+            ("pages", "Pages"),
+            ("city", "City"),
+            ("publisher", "Publisher"),
+        ],
+    ),
+    ("report", "Report", &[("author", "Author"), ("title", "Title"), ("year", "Year"), ("publisher", "Institution"), ("city", "City")]),
+    (
+        "website",
+        "Website",
+        &[
+            ("author", "Author"),
+            ("title", "Page title"),
+            ("journal", "Site name"),
+            ("year", "Year"),
+            ("month", "Month"),
+            ("day", "Day"),
+            ("url", "URL"),
+        ],
+    ),
+    ("film", "Film", &[("author", "Author"), ("title", "Title"), ("publisher", "Studio"), ("year", "Year")]),
+    ("other", "Other", &[("author", "Author"), ("title", "Title"), ("year", "Year"), ("city", "City"), ("publisher", "Publisher")]),
+];
+
+/// Every field "show all bibliography fields" adds, after the type's own.
+const ALL_FIELDS: [(&str, &str); 17] = [
+    ("author", "Author"),
+    ("editor", "Editor"),
+    ("title", "Title"),
+    ("journal", "Container Title"),
+    ("year", "Year"),
+    ("month", "Month"),
+    ("day", "Day"),
+    ("city", "City"),
+    ("publisher", "Publisher"),
+    ("edition", "Edition"),
+    ("volume", "Volume"),
+    ("issue", "Issue"),
+    ("pages", "Pages"),
+    ("url", "URL"),
+    ("doi", "DOI"),
+    ("accessed", "Accessed on"),
+    ("tag", "Tag"),
+];
+
+fn field_mut<'a>(s: &'a mut Source, key: &str) -> Option<&'a mut String> {
+    Some(match key {
+        "author" => &mut s.author,
+        "editor" => &mut s.editor,
+        "title" => &mut s.title,
+        "journal" => &mut s.journal,
+        "year" => &mut s.year,
+        "month" => &mut s.month,
+        "day" => &mut s.day,
+        "city" => &mut s.city,
+        "publisher" => &mut s.publisher,
+        "edition" => &mut s.edition,
+        "volume" => &mut s.volume,
+        "issue" => &mut s.issue,
+        "pages" => &mut s.pages,
+        "url" => &mut s.url,
+        "doi" => &mut s.doi,
+        "accessed" => &mut s.accessed,
+        "tag" => &mut s.tag,
+        _ => return None,
+    })
+}
+
+/// Create Source / Edit Source.
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SourceForm {
+    pub source: Source,
+    pub show_all: bool,
+    /// Editing a source that is there (its tag stays: citations point at it).
+    pub edit: bool,
+    /// Insert a citation of the source on OK (Insert Citation › Add New Source…).
+    pub cite: bool,
+    /// Opened from the Source Manager, which comes back when this closes.
+    pub back: bool,
+}
+
+impl SourceForm {
+    pub fn new(cite: bool, back: bool) -> SourceForm {
+        SourceForm { source: Source { kind: "book".into(), ..Default::default() }, show_all: false, edit: false, cite, back }
+    }
+
+    /// The fields shown: the type's own, or every field.
+    pub fn fields(&self) -> Vec<(&'static str, &'static str)> {
+        let own = SOURCE_TYPES.iter().find(|(k, ..)| *k == self.source.kind).map(|(_, _, f)| *f).unwrap_or(SOURCE_TYPES[0].2);
+        let mut v: Vec<(&str, &str)> = own.to_vec();
+        if self.show_all {
+            v.extend(ALL_FIELDS.iter().filter(|(k, _)| !own.iter().any(|(o, _)| o == k) && *k != "tag").copied());
+        }
+        v.push(("tag", "Tag"));
+        v
+    }
+}
+
+fn source_ui(app: &mut WordApp, ui: &mut Ui, f: &mut SourceForm) -> Next {
+    egui::Grid::new("src").num_columns(2).spacing(vec2(10.0, 5.0)).show(ui, |ui| {
+        ui.label(tl!("Source type:"));
+        let shown = SOURCE_TYPES.iter().find(|(k, ..)| *k == f.source.kind).map(|(_, l, _)| tl!(l).to_string()).unwrap_or_default();
+        egui::ComboBox::from_id_salt("src_kind").selected_text(shown).width(200.0).show_ui(ui, |ui| {
+            for (k, l, _) in SOURCE_TYPES {
+                ui.selectable_value(&mut f.source.kind, k.to_string(), tl!(l));
+            }
+        });
+        ui.end_row();
+        let edit = f.edit;
+        for (key, label) in f.fields() {
+            ui.label(format!("{}:", tl!(label)));
+            if let Some(v) = field_mut(&mut f.source, key) {
+                let hint = match key {
+                    "author" => tl!("Last, First; Last, First"),
+                    "tag" => tl!("Made from the author and year when empty"),
+                    _ => "",
+                };
+                ui.add_enabled(!(edit && key == "tag"), egui::TextEdit::singleline(v).desired_width(260.0).hint_text(hint));
+            }
+            ui.end_row();
+        }
+    });
+    ui.checkbox(&mut f.show_all, tl!("Show every bibliography field"));
+    let (ok, cancel) = buttons(ui, tl!("OK"));
+    if ok {
+        let src = serde_json::to_value(&f.source).unwrap_or(Value::Null);
+        let r = if f.cite { app.run("references.citation", json!({"source": src})) } else { app.run("references.sources", json!({"add": src})) };
+        if let Err(e) = r {
+            app.status(e);
+        }
+    }
+    if (ok || cancel) && f.back {
+        return go(RefsDialog::Sources { selected: None });
+    }
+    if ok || cancel { Next::Close } else { Next::Stay }
+}
+
+fn sources_ui(app: &mut WordApp, ui: &mut Ui, selected: &mut Option<usize>) -> Next {
+    let t = Tokens::get(ui.ctx());
+    let list: Vec<String> = app
+        .session
+        .doc
+        .sources
+        .iter()
+        .map(|s| {
+            let parts: Vec<&str> = [s.author.as_str(), s.title.as_str(), s.year.as_str()].into_iter().filter(|x| !x.is_empty()).collect();
+            format!("{} — {}", s.tag, parts.join("; "))
+        })
+        .collect();
+    ui.label(tl!("Sources in this document:"));
+    egui::Frame::new().stroke(egui::Stroke::new(1.0, t.border_strong)).inner_margin(4.0).show(ui, |ui| {
+        ui.set_min_size(vec2(380.0, 160.0));
+        egui::ScrollArea::vertical().max_height(220.0).show(ui, |ui| {
+            if list.is_empty() {
+                ui.label(egui::RichText::new(tl!("No sources yet.")).color(t.text_dim));
+            }
+            for (i, l) in list.iter().enumerate() {
+                if ui.selectable_label(*selected == Some(i), l).clicked() {
+                    *selected = Some(i);
+                }
+            }
+        });
+    });
+    let src = selected.and_then(|i| app.session.doc.sources.get(i)).cloned();
+    let mut next = Next::Stay;
+    ui.add_space(6.0);
+    ui.horizontal(|ui| {
+        if ui.button(tl!("New…")).clicked() {
+            next = go(RefsDialog::Source(Box::new(SourceForm::new(false, true))));
+        }
+        if ui.add_enabled(src.is_some(), egui::Button::new(tl!("Edit…"))).clicked()
+            && let Some(s) = &src
+        {
+            next = go(RefsDialog::Source(Box::new(SourceForm { source: s.clone(), show_all: false, edit: true, cite: false, back: true })));
+        }
+        if ui.add_enabled(src.is_some(), egui::Button::new(tl!("Delete"))).clicked()
+            && let Some(s) = &src
+        {
+            if let Err(e) = app.run("references.sources", json!({"remove": s.tag})) {
+                app.status(e);
+            }
+            *selected = None;
+        }
+        if ui.add_enabled(src.is_some(), egui::Button::new(tl!("Insert Citation"))).clicked()
+            && let Some(s) = &src
+        {
+            if let Err(e) = app.run("references.citation", json!({"tag": s.tag})) {
+                app.status(e);
+            }
+            next = Next::Close;
+        }
+    });
+    ui.add_space(8.0);
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if ui.button(tl!("Close")).clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+                next = Next::Close;
+            }
+        });
+    });
+    next
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+    use wordcraft_doc::{InlineObject, StoryRef};
+    use wordcraft_engine::Session;
+
+    use super::*;
+    use crate::Services;
+
+    fn app(text: &str) -> WordApp {
+        WordApp::new(Session::new(wordcraft_doc::Document::from_text(text)), Services::default())
+    }
+
+    fn form(a: &WordApp) -> RefsDialog {
+        match &a.dialog {
+            Some(Dialog::Refs(d)) => (**d).clone(),
+            d => panic!("no references dialog: {d:?}"),
+        }
+    }
+
+    fn instrs(a: &WordApp) -> Vec<String> {
+        let doc = &a.session.doc;
+        doc.para_paths(StoryRef::Body)
+            .iter()
+            .filter_map(|p| doc.para(StoryRef::Body, p))
+            .flat_map(|p| p.objects.iter())
+            .filter_map(|o| match o {
+                InlineObject::Field { instr, .. } => Some(instr.clone()),
+                _ => None,
+            })
+            .collect()
+    }
+
+    /// #402: Insert Caption opens the dialog; a new label is kept with the interface settings,
+    /// and Numbering's chapter options become `STYLEREF` and `SEQ … \s` fields.
+    #[test]
+    fn caption_dialog_numbers_with_chapters() {
+        let mut a = app("Results\nA chart");
+        a.run("select.text", json!({"text": "Results"})).unwrap();
+        a.run("styles.apply", json!({"style": "Heading 1"})).unwrap();
+        a.run("select.text", json!({"text": "A chart"})).unwrap();
+        assert_eq!(a.run("references.caption", json!({})).unwrap(), json!({"pending": "caption"}));
+        let RefsDialog::Caption(mut f) = form(&a) else { panic!() };
+        assert_eq!((f.label.as_str(), f.labels.len()), ("Figure", 3));
+        // New Label…, then Numbering… with a chapter number.
+        f.new_label = "Plate".into();
+        a.dialog = None;
+        a.ui.caption_labels.push(f.new_label.clone());
+        f.label = "Plate".into();
+        f.format = "ALPHABETIC".into();
+        f.chapter = true;
+        f.separator = ".".into();
+        f.text = "Growth".into();
+        assert_eq!(f.preview(), "Plate 1.A");
+        a.run("references.caption", f.params()).unwrap();
+        assert!(instrs(&a).contains(&"SEQ Plate \\* ALPHABETIC \\s 1".to_string()), "{:?}", instrs(&a));
+        assert!(a.session.doc.plain_text(StoryRef::Body).contains("Plate 1.A: Growth"));
+        // The label is offered next time and saved with the preferences.
+        assert!(CaptionForm::read(&a).labels.contains(&"Plate".to_string()));
+        assert_eq!(a.prefs().caption_labels, vec!["Plate".to_string()]);
+    }
+
+    /// #402: Mark Entry opens with the selection; Insert Index opens with Word's defaults and
+    /// reads the index back; both write their switches.
+    #[test]
+    fn index_and_mark_entry_dialogs_write_switches() {
+        let mut a = app("Kilns are hot.\nMore text.");
+        a.run("select.text", json!({"text": "Kilns"})).unwrap();
+        assert_eq!(a.run("references.markEntry", json!({})).unwrap(), json!({"pending": "markEntry"}));
+        let RefsDialog::MarkEntry(mut m) = form(&a) else { panic!() };
+        assert_eq!(m.entry, "Kilns");
+        m.subentry = "firing".into();
+        m.italic = true;
+        a.run("references.markEntry", m.params(false)).unwrap();
+        assert!(instrs(&a).contains(&"XE \"Kilns:firing\" \\i".to_string()), "{:?}", instrs(&a));
+        a.run("caret.docEnd", json!({})).unwrap();
+        assert_eq!(a.run("references.index", json!({})).unwrap(), json!({"pending": "index"}));
+        let RefsDialog::Index(mut f) = form(&a) else { panic!() };
+        assert_eq!((f.columns, f.kind.as_str(), f.headings), (2, "indented", true));
+        f.kind = "runIn".into();
+        f.right_align = true;
+        a.run("references.index", f.params()).unwrap();
+        assert!(instrs(&a).contains(&"INDEX \\h \"A\" \\c \"2\" \\e \"\t\" \\r".to_string()), "{:?}", instrs(&a));
+        assert_eq!(IndexForm::read(&a), f, "the dialog shows the index's settings");
+    }
+
+    /// #402: Custom Table of Contents and its Options make the TOC switches, and the dialog
+    /// opens again with them.
+    #[test]
+    fn custom_table_of_contents_dialog() {
+        let mut a = app("Intro\nNote");
+        a.run("select.text", json!({"text": "Intro"})).unwrap();
+        a.run("styles.apply", json!({"style": "Heading 1"})).unwrap();
+        a.run("select.text", json!({"text": "Note"})).unwrap();
+        a.run("styles.apply", json!({"style": "Quote"})).unwrap();
+        a.run("caret.docStart", json!({})).unwrap();
+        a.run("ui.dialog", json!({"name": "toc"})).unwrap();
+        let RefsDialog::Toc(mut f) = form(&a) else { panic!() };
+        assert_eq!((f.levels, f.hyperlinks, f.right_align, f.heading_styles, f.outline_levels), (3, true, true, true, true));
+        f.levels = 2;
+        f.hyperlinks = false;
+        f.leader = "hyphen".into();
+        // Options…: the Quote style at level 2.
+        f.style_levels.iter_mut().find(|(n, _)| n == "Quote").unwrap().1 = 2;
+        a.run("references.toc", f.params()).unwrap();
+        assert_eq!(instrs(&a)[0], "TOC \\o \"1-2\" \\z \\u \\t \"Quote,2\"");
+        let text = a.session.doc.plain_text(StoryRef::Body);
+        assert!(text.contains("Intro\t1") && text.contains("Note\t1"), "{text}");
+        assert_eq!(TocForm::read(&a), f);
+    }
+
+    /// #402: Insert Citation without a source opens Create Source; the type picks the fields,
+    /// "show all" adds the rest, and Edit Source from the Source Manager updates the citation.
+    #[test]
+    fn create_and_edit_source() {
+        let mut a = app("Studios matter ");
+        a.run("caret.docEnd", json!({})).unwrap();
+        assert_eq!(a.run("references.citation", json!({})).unwrap(), json!({"pending": "createSource"}));
+        let RefsDialog::Source(mut f) = form(&a) else { panic!() };
+        let f = &mut *f;
+        f.source.kind = "website".into();
+        let shown = f.fields().len();
+        assert!(f.fields().iter().any(|(k, l)| *k == "url" && *l == "URL"));
+        f.show_all = true;
+        assert!(f.fields().len() > shown && f.fields().iter().any(|(k, _)| *k == "doi"));
+        for (k, v) in [("author", "Rivera, Alex"), ("title", "Kilns Online"), ("year", "2024"), ("url", "https://example.org"), ("doi", "10.1/x")] {
+            *field_mut(&mut f.source, k).unwrap() = v.into();
+        }
+        a.run("references.citation", json!({"source": serde_json::to_value(&f.source).unwrap()})).unwrap();
+        assert!(a.session.doc.plain_text(StoryRef::Body).contains("(Rivera, 2024)"));
+        assert_eq!(a.session.doc.sources[0].doi, "10.1/x");
+        // Manage Sources › Edit…: a new year shows in the citation.
+        assert_eq!(a.run("references.sources", json!({})).unwrap(), json!({"pending": "sourceManager"}));
+        let mut src = a.session.doc.sources[0].clone();
+        src.year = "2025".into();
+        a.run("references.sources", json!({"add": src})).unwrap();
+        assert!(a.session.doc.plain_text(StoryRef::Body).contains("(Rivera, 2025)"), "{}", a.session.doc.plain_text(StoryRef::Body));
+        assert_eq!(a.session.doc.sources.len(), 1);
+    }
+}
diff --git a/crates/ui-egui/src/dialogs_review.rs b/crates/ui-egui/src/dialogs_review.rs
new file mode 100644
index 0000000000..500a1cabcd
--- /dev/null
+++ b/crates/ui-egui/src/dialogs_review.rs
@@ -0,0 +1,829 @@
+//! Review dialogs and the Restrict Editing pane (#412): Compare / Combine Documents (with the
+//! More >> comparison settings), AutoCorrect Options (AutoCorrect, AutoFormat As You Type and
+//! Math AutoCorrect) and the Restrict Editing side pane. Each ends by running a command
+//! (`review.compare`, `review.combine`, `tools.autocorrect`, `review.restrict`), so scripts and
+//! agents get the same result without them. Shown through [`crate::dialogs::Dialog::Review`] and
+//! [`crate::panes`].
+
+use egui::{Color32, Ui, vec2};
+use serde::Serialize;
+use serde_json::{Value, json};
+use wordcraft_engine::Password;
+use wordcraft_engine::cmd::tools::AutoCorrectPrefs;
+
+use crate::WordApp;
+use crate::theme::semibold;
+
+#[derive(Clone, Debug, Serialize)]
+#[serde(tag = "form", rename_all = "camelCase")]
+pub enum ReviewDialog {
+    Compare(CompareForm),
+    AutoCorrect(Box<AutoCorrectForm>),
+}
+
+impl ReviewDialog {
+    pub fn name(&self) -> &'static str {
+        match self {
+            ReviewDialog::Compare(f) if f.combine => "combine",
+            ReviewDialog::Compare(_) => "compare",
+            ReviewDialog::AutoCorrect(_) => "autoCorrect",
+        }
+    }
+
+    /// The window title (English; the caller translates it).
+    pub fn title(&self) -> &'static str {
+        match self {
+            ReviewDialog::Compare(f) if f.combine => "Combine Documents",
+            ReviewDialog::Compare(_) => "Compare Documents",
+            ReviewDialog::AutoCorrect(_) => "AutoCorrect",
+        }
+    }
+}
+
+/// The dialog `ui.dialog` opens by `name`: `compare`, `combine` or `autoCorrect`.
+/// `restrictEditing` opens the Restrict Editing pane instead (no dialog).
+pub fn open(name: &str, app: &mut WordApp) -> Option<ReviewDialog> {
+    Some(match name {
+        "compare" | "combine" => ReviewDialog::Compare(CompareForm::new(app, name == "combine")),
+        "autoCorrect" => ReviewDialog::AutoCorrect(Box::new(AutoCorrectForm::new(app))),
+        "restrictEditing" => {
+            app.restrict.open = true;
+            return None;
+        }
+        _ => return None,
+    })
+}
+
+/// Draws the dialog; returns true to close it.
+pub fn body(app: &mut WordApp, ui: &mut Ui, d: &mut ReviewDialog) -> bool {
+    match d {
+        ReviewDialog::Compare(f) => compare_ui(app, ui, f),
+        ReviewDialog::AutoCorrect(f) => autocorrect_ui(app, ui, f),
+    }
+}
+
+/// OK / Cancel; returns (ok, cancel). `ok_enabled` greys OK out.
+fn buttons(ui: &mut Ui, ok_enabled: bool) -> (bool, bool) {
+    let mut r = (false, false);
+    ui.add_space(8.0);
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            if ui.button(tl!("Cancel")).clicked() || ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+                r.1 = true;
+            }
+            let okb =
+                ui.add_enabled(ok_enabled, egui::Button::new(egui::RichText::new(tl!("OK")).color(Color32::WHITE)).fill(crate::theme::APP_COLOR));
+            if okb.clicked() {
+                r.0 = true;
+            }
+        });
+    });
+    r
+}
+
+fn heading(ui: &mut Ui, s: &str) {
+    ui.add_space(6.0);
+    ui.label(egui::RichText::new(tl!(s)).font(semibold(12.5)));
+}
+
+fn error(ui: &mut Ui, message: &str) {
+    if !message.is_empty() {
+        ui.label(egui::RichText::new(message).small().color(ui.visuals().error_fg_color));
+    }
+}
+
+// ---------------------------------------------------------------------------------------------
+// Compare / Combine
+
+/// The comparison settings (More >>), in the order the dialog shows them, with their
+/// `review.compare` parameter names.
+pub const COMPARE_SETTINGS: [(&str, &str); 10] = [
+    ("moves", "Moves"),
+    ("comments", "Comments"),
+    ("formatting", "Formatting"),
+    ("caseChanges", "Case changes"),
+    ("whiteSpace", "White space"),
+    ("tables", "Tables"),
+    ("headersFooters", "Headers and footers"),
+    ("footnotes", "Footnotes and endnotes"),
+    ("textBoxes", "Text boxes"),
+    ("fields", "Fields"),
+];
+
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct CompareForm {
+    pub combine: bool,
+    /// The original is the open document (else the file `original`).
+    pub original_current: bool,
+    pub original: String,
+    pub revised: String,
+    /// Label changes with.
+    pub author: String,
+    /// More >> shown.
+    pub more: bool,
+    /// [`COMPARE_SETTINGS`], all on by default as in Word.
+    pub settings: [bool; 10],
+    pub character_level: bool,
+    /// Show changes in: `original`, `revised` or `new`.
+    pub show_in: String,
+    pub message: String,
+}
+
+impl CompareForm {
+    pub fn new(app: &WordApp, combine: bool) -> CompareForm {
+        CompareForm {
+            combine,
+            original_current: true,
+            original: String::new(),
+            revised: String::new(),
+            author: app.session.author.clone(),
+            more: false,
+            settings: [true; 10],
+            character_level: false,
+            show_in: "new".into(),
+            message: String::new(),
+        }
+    }
+
+    /// The `review.compare` / `review.combine` parameters; `None` until a revised document is
+    /// chosen.
+    pub fn params(&self) -> Option<Value> {
+        let revised = self.revised.trim();
+        if revised.is_empty() || (!self.original_current && self.original.trim().is_empty()) {
+            return None;
+        }
+        let mut v = json!({
+            "path": revised,
+            "author": self.author.trim(),
+            "level": if self.character_level { "character" } else { "word" },
+            "showIn": self.show_in,
+        });
+        if !self.original_current {
+            v["original"] = json!(self.original.trim());
+        }
+        for ((key, _), on) in COMPARE_SETTINGS.iter().zip(self.settings) {
+            v[*key] = json!(on);
+        }
+        Some(v)
+    }
+}
+
+/// Can this front end pick files (desktop), rather than only receive them (web)?
+fn can_browse(app: &WordApp) -> bool {
+    app.services.file_dialog.is_some() || app.services.pick_open.is_some()
+}
+
+/// Put a picked file into the open Compare dialog (`revised`: the revised document's box).
+pub(crate) fn set_compare_path(app: &mut WordApp, revised: bool, path: String) {
+    if let Some(crate::dialogs::Dialog::Review(d)) = app.dialog.as_mut()
+        && let ReviewDialog::Compare(f) = &mut **d
+    {
+        if revised {
+            f.revised = path;
+        } else {
+            f.original = path;
+            f.original_current = false;
+        }
+    }
+}
+
+fn compare_ui(app: &mut WordApp, ui: &mut Ui, f: &mut CompareForm) -> bool {
+    let browse = can_browse(app);
+    let mut pick: Option<bool> = None;
+    if !browse {
+        ui.label(egui::RichText::new(tl!("Comparing with another file needs the desktop app.")).small().weak());
+    }
+    egui::Grid::new("compare_files").num_columns(2).spacing(vec2(16.0, 4.0)).show(ui, |ui| {
+        ui.vertical(|ui| {
+            heading(ui, "Original document");
+            ui.radio_value(&mut f.original_current, true, tl!("This document"));
+            ui.horizontal(|ui| {
+                ui.radio_value(&mut f.original_current, false, "");
+                ui.add_enabled(browse, egui::TextEdit::singleline(&mut f.original).desired_width(170.0).hint_text(tl!("Another file")));
+                if ui.add_enabled(browse, egui::Button::new(tl!("Browse…"))).clicked() {
+                    pick = Some(false);
+                }
+            });
+        });
+        ui.vertical(|ui| {
+            heading(ui, "Revised document");
+            ui.horizontal(|ui| {
+                ui.add_enabled(browse, egui::TextEdit::singleline(&mut f.revised).desired_width(170.0));
+                if ui.add_enabled(browse, egui::Button::new(tl!("Browse…"))).clicked() {
+                    pick = Some(true);
+                }
+            });
+            ui.horizontal(|ui| {
+                ui.label(tl!("Label changes with:"));
+                ui.add(egui::TextEdit::singleline(&mut f.author).desired_width(120.0));
+            });
+        });
+        ui.end_row();
+    });
+    ui.add_space(4.0);
+    if ui.button(if f.more { tl!("<< Less") } else { tl!("More >>") }).clicked() {
+        f.more = !f.more;
+    }
+    if f.more {
+        heading(ui, "Comparison settings");
+        egui::Grid::new("compare_settings").num_columns(2).spacing(vec2(16.0, 2.0)).show(ui, |ui| {
+            for (i, (_, label)) in COMPARE_SETTINGS.iter().enumerate() {
+                if let Some(on) = f.settings.get_mut(i) {
+                    ui.checkbox(on, tl!(label));
+                }
+                if i % 2 == 1 {
+                    ui.end_row();
+                }
+            }
+        });
+        ui.label(
+            egui::RichText::new(tl!("Formatting, case changes, white space and tables are compared; the other settings are kept for later."))
+                .small()
+                .weak(),
+        );
+        egui::Grid::new("compare_show").num_columns(2).spacing(vec2(24.0, 2.0)).show(ui, |ui| {
+            ui.vertical(|ui| {
+                heading(ui, "Show changes at:");
+                ui.radio_value(&mut f.character_level, false, tl!("Word level"));
+                ui.radio_value(&mut f.character_level, true, tl!("Character level"));
+            });
+            ui.vertical(|ui| {
+                heading(ui, "Show changes in:");
+                for (v, l) in [("original", "Original document"), ("revised", "Revised document"), ("new", "New document")] {
+                    ui.radio_value(&mut f.show_in, v.to_string(), tl!(l));
+                }
+            });
+            ui.end_row();
+        });
+    }
+    if let Some(revised) = pick {
+        // A blocking picker answers now, while this dialog is out of `app.dialog`: fill it here.
+        if app.services.file_dialog.is_none()
+            && let Some(pick_open) = &app.services.pick_open
+        {
+            if let Some(path) = pick_open("document") {
+                if revised {
+                    f.revised = path;
+                } else {
+                    f.original = path;
+                    f.original_current = false;
+                }
+            }
+        } else {
+            let _ = app.ask_file(
+                crate::file_dialogs::FileDialogRequest::Open { purpose: "document".into() },
+                crate::file_dialogs::AfterPick::ComparePath { revised },
+            );
+        }
+    }
+    error(ui, &f.message);
+    let params = f.params();
+    let (ok, cancel) = buttons(ui, params.is_some());
+    if ok && let Some(params) = params {
+        let id = if f.combine { "review.combine" } else { "review.compare" };
+        match app.run(id, params) {
+            Ok(v) => {
+                let n = v.get("changes").and_then(Value::as_u64).unwrap_or(0).to_string();
+                app.status(crate::i18n::fmt(tl!("Compared: {changes} changes"), &[("changes", &n)]));
+                return true;
+            }
+            Err(e) => {
+                f.message = e;
+                return false;
+            }
+        }
+    }
+    cancel
+}
+
+// ---------------------------------------------------------------------------------------------
+// AutoCorrect Options
+
+#[derive(Clone, Debug, PartialEq, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AutoCorrectForm {
+    /// 0 AutoCorrect, 1 AutoFormat As You Type, 2 Math AutoCorrect.
+    pub tab: u8,
+    /// The options as edited (applied on OK); the lists change at once, as in Word.
+    pub options: AutoCorrectPrefs,
+    /// Replace / With boxes.
+    pub from: String,
+    pub to: String,
+    /// Exceptions shown, and the exception being typed.
+    pub show_exceptions: bool,
+    pub exception: String,
+    /// Math AutoCorrect filter.
+    pub math_filter: String,
+    pub message: String,
+}
+
+impl AutoCorrectForm {
+    pub fn new(app: &WordApp) -> AutoCorrectForm {
+        AutoCorrectForm {
+            tab: 0,
+            options: app.session.prefs.autocorrect.clone(),
+            from: String::new(),
+            to: String::new(),
+            show_exceptions: false,
+            exception: String::new(),
+            math_filter: String::new(),
+            message: String::new(),
+        }
+    }
+
+    /// The `tools.autocorrect` switches.
+    pub fn params(&self) -> Value {
+        let o = &self.options;
+        json!({
+            "replaceText": o.replace_text,
+            "capSentences": o.cap_sentences,
+            "capCells": o.cap_cells,
+            "capDays": o.cap_days,
+            "smartQuotes": o.smart_quotes,
+            "fractions": o.fractions,
+            "ordinals": o.ordinals,
+            "dashes": o.dashes,
+            "links": o.links,
+            "bullets": o.bullets,
+            "numbering": o.numbering,
+            "borderLines": o.border_lines,
+        })
+    }
+}
+
+/// Run a list change at once and take the lists it reports back.
+fn list_change(app: &mut WordApp, f: &mut AutoCorrectForm, params: Value) -> bool {
+    match app.run("tools.autocorrect", params) {
+        Ok(_) => {
+            let now = app.session.prefs.autocorrect.clone();
+            f.options.entries = now.entries;
+            f.options.removed = now.removed;
+            f.options.exceptions = now.exceptions;
+            f.options.exceptions_removed = now.exceptions_removed;
+            f.message.clear();
+            true
+        }
+        Err(e) => {
+            f.message = e;
+            false
+        }
+    }
+}
+
+fn autocorrect_ui(app: &mut WordApp, ui: &mut Ui, f: &mut AutoCorrectForm) -> bool {
+    ui.horizontal(|ui| {
+        for (i, l) in ["AutoCorrect", "AutoFormat As You Type", "Math AutoCorrect"].into_iter().enumerate() {
+            if ui.selectable_label(f.tab == i as u8, tl!(l)).clicked() {
+                f.tab = i as u8;
+            }
+        }
+    });
+    ui.separator();
+    match f.tab {
+        0 => autocorrect_tab(app, ui, f),
+        1 => {
+            let o = &mut f.options;
+            heading(ui, "Replace as you type");
+            ui.checkbox(&mut o.smart_quotes, tl!("Smart quotes instead of straight quotes"));
+            ui.checkbox(&mut o.fractions, tl!("Fractions (1/2) as fraction characters (½)"));
+            ui.checkbox(&mut o.ordinals, tl!("Ordinals (1st) as superscript"));
+            ui.checkbox(&mut o.dashes, tl!("Hyphens (--) as dashes (—)"));
+            ui.checkbox(&mut o.links, tl!("Internet addresses as links"));
+            heading(ui, "Apply as you type");
+            ui.checkbox(&mut o.bullets, tl!("Automatic bulleted lists"));
+            ui.checkbox(&mut o.numbering, tl!("Automatic numbered lists"));
+            ui.checkbox(&mut o.border_lines, tl!("Border lines"));
+        }
+        _ => math_tab(ui, f),
+    }
+    error(ui, &f.message);
+    let (ok, cancel) = buttons(ui, true);
+    if ok {
+        if let Err(e) = app.run("tools.autocorrect", f.params()) {
+            f.message = e;
+            return false;
+        }
+        return true;
+    }
+    cancel
+}
+
+fn autocorrect_tab(app: &mut WordApp, ui: &mut Ui, f: &mut AutoCorrectForm) {
+    let o = &mut f.options;
+    ui.checkbox(&mut o.cap_sentences, tl!("Capitalize first letter of sentences"));
+    ui.horizontal(|ui| {
+        ui.add_space(18.0);
+        if ui.small_button(tl!("Exceptions…")).clicked() {
+            f.show_exceptions = !f.show_exceptions;
+        }
+    });
+    if f.show_exceptions {
+        exceptions(app, ui, f);
+    }
+    let o = &mut f.options;
+    ui.checkbox(&mut o.cap_cells, tl!("Capitalize first letter of table cells"));
+    ui.checkbox(&mut o.cap_days, tl!("Capitalize names of days"));
+    ui.checkbox(&mut o.replace_text, tl!("Replace text as you type"));
+    egui::Grid::new("ac_boxes").num_columns(2).spacing(vec2(8.0, 2.0)).show(ui, |ui| {
+        ui.label(tl!("Replace:"));
+        ui.label(tl!("With:"));
+        ui.end_row();
+        ui.add(egui::TextEdit::singleline(&mut f.from).desired_width(110.0));
+        ui.add(egui::TextEdit::singleline(&mut f.to).desired_width(260.0));
+        ui.end_row();
+    });
+    // The list, filtered to what's typed in Replace (as Word scrolls to it).
+    let list = f.options.list();
+    let typed = f.from.trim().to_lowercase();
+    let mut picked: Option<(String, String)> = None;
+    egui::ScrollArea::vertical().id_salt("ac_list").max_height(170.0).auto_shrink([false, true]).show(ui, |ui| {
+        egui::Grid::new("ac_list_grid").num_columns(2).spacing(vec2(8.0, 1.0)).striped(true).show(ui, |ui| {
+            for (a, b, _) in list.iter().filter(|(a, _, _)| typed.is_empty() || a.to_lowercase().starts_with(&typed)).take(500) {
+                let selected = f.from == *a;
+                if ui.add_sized(vec2(110.0, 16.0), egui::Button::selectable(selected, a.as_str())).clicked() {
+                    picked = Some((a.clone(), b.clone()));
+                }
+                ui.label(b.as_str());
+                ui.end_row();
+            }
+        });
+    });
+    if let Some((a, b)) = picked {
+        f.from = a;
+        f.to = b;
+    }
+    let exists = list.iter().any(|(a, _, _)| *a == f.from);
+    let same = list.iter().any(|(a, b, _)| *a == f.from && *b == f.to);
+    ui.horizontal(|ui| {
+        let label = if exists { tl!("Replace") } else { tl!("Add") };
+        if ui.add_enabled(!f.from.trim().is_empty() && !same, egui::Button::new(label)).clicked() {
+            let p = json!({"add": {"from": f.from, "to": f.to}});
+            if list_change(app, f, p) {
+                f.from.clear();
+                f.to.clear();
+            }
+        }
+        if ui.add_enabled(exists, egui::Button::new(tl!("Delete"))).clicked() {
+            let p = json!({"delete": f.from});
+            if list_change(app, f, p) {
+                f.from.clear();
+                f.to.clear();
+            }
+        }
+    });
+}
+
+fn exceptions(app: &mut WordApp, ui: &mut Ui, f: &mut AutoCorrectForm) {
+    egui::Frame::group(ui.style()).show(ui, |ui| {
+        ui.label(tl!("Don't capitalize after:"));
+        let list = f.options.exception_list();
+        let mut picked = None;
+        egui::ScrollArea::vertical().id_salt("ac_exceptions").max_height(90.0).auto_shrink([false, true]).show(ui, |ui| {
+            for e in &list {
+                if ui.add(egui::Button::selectable(f.exception == *e, e.as_str())).clicked() {
+                    picked = Some(e.clone());
+                }
+            }
+        });
+        if let Some(e) = picked {
+            f.exception = e;
+        }
+        ui.horizontal(|ui| {
+            ui.add(egui::TextEdit::singleline(&mut f.exception).desired_width(110.0));
+            let known = list.contains(&f.exception.trim().to_lowercase());
+            if ui.add_enabled(!f.exception.trim().is_empty() && !known, egui::Button::new(tl!("Add"))).clicked() {
+                let p = json!({"addException": f.exception});
+                if list_change(app, f, p) {
+                    f.exception.clear();
+                }
+            }
+            if ui.add_enabled(known, egui::Button::new(tl!("Delete"))).clicked() {
+                let p = json!({"deleteException": f.exception});
+                if list_change(app, f, p) {
+                    f.exception.clear();
+                }
+            }
+        });
+    });
+}
+
+fn math_tab(ui: &mut Ui, f: &mut AutoCorrectForm) {
+    ui.label(egui::RichText::new(tl!("In equations, typing a name after a backslash replaces it with its symbol.")).small().weak());
+    ui.horizontal(|ui| {
+        ui.label(tl!("Replace:"));
+        ui.add(egui::TextEdit::singleline(&mut f.math_filter).desired_width(140.0));
+    });
+    let filter = f.math_filter.trim().trim_start_matches('\\').to_string();
+    egui::ScrollArea::vertical().id_salt("ac_math").max_height(240.0).auto_shrink([false, true]).show(ui, |ui| {
+        egui::Grid::new("ac_math_grid").num_columns(2).spacing(vec2(16.0, 1.0)).striped(true).show(ui, |ui| {
+            for (name, c) in wordcraft_doc::math_symbols::SYMBOLS.iter().filter(|(n, _)| filter.is_empty() || n.starts_with(filter.as_str())) {
+                ui.label(format!("\\{name}"));
+                ui.label(c.to_string());
+                ui.end_row();
+            }
+        });
+    });
+}
+
+// ---------------------------------------------------------------------------------------------
+// Restrict Editing pane
+
+/// The Restrict Editing pane's own state: what is being set up before protection starts, and
+/// the passwords being typed.
+#[derive(Clone, Debug, Default)]
+pub struct RestrictPane {
+    pub open: bool,
+    /// 1. Formatting restrictions: limit formatting to a selection of styles.
+    pub formatting: bool,
+    /// Its style list shown, and the styles allowed (by id); `None` until first shown (all).
+    pub show_styles: bool,
+    pub allowed: Option<Vec<String>>,
+    /// 2. Editing restrictions on, and which (index into [`EDIT_MODES`]).
+    pub editing: bool,
+    pub mode: usize,
+    /// 3. Asking for the password to start (or to stop) protection.
+    pub asking: bool,
+    pub password: Password,
+    pub confirm: Password,
+    pub message: String,
+}
+
+/// The editing restrictions, with their `review.restrict` modes.
+pub const EDIT_MODES: [(&str, &str); 4] =
+    [("readOnly", "No changes (read only)"), ("trackedChanges", "Tracked changes"), ("comments", "Comments"), ("forms", "Filling in forms")];
+
+/// The styles the formatting restriction lists: paragraph and character styles not hidden.
+fn listed_styles(app: &WordApp) -> Vec<(String, String)> {
+    use wordcraft_doc::StyleKind;
+    let mut v: Vec<(String, String)> = app
+        .session
+        .doc
+        .styles
+        .styles
+        .iter()
+        .filter(|s| matches!(s.kind, StyleKind::Paragraph | StyleKind::Character) && !s.hidden)
+        .map(|s| (s.id.clone(), if s.name.is_empty() { s.id.clone() } else { s.name.clone() }))
+        .collect();
+    v.sort_by_key(|a| a.1.to_lowercase());
+    v
+}
+
+pub fn restrict_pane(app: &mut WordApp, ui: &mut Ui) {
+    let mut st = std::mem::take(&mut app.restrict);
+    let enforced = app.session.doc.settings.protection.clone();
+    egui::ScrollArea::vertical().id_salt("restrict_pane").show(ui, |ui| match &enforced {
+        Some(mode) => enforced_ui(app, ui, &mut st, mode),
+        None => setup_ui(app, ui, &mut st),
+    });
+    app.restrict = st;
+}
+
+fn setup_ui(app: &mut WordApp, ui: &mut Ui, st: &mut RestrictPane) {
+    heading(ui, "1. Formatting restrictions");
+    ui.checkbox(&mut st.formatting, tl!("Limit formatting to a selection of styles"));
+    if st.formatting && ui.small_button(tl!("Settings…")).clicked() {
+        st.show_styles = !st.show_styles;
+    }
+    let styles = listed_styles(app);
+    if st.allowed.is_none() {
+        // Start from the document's own locked styles.
+        let doc = &app.session.doc.styles;
+        st.allowed = Some(styles.iter().filter(|(id, _)| !doc.get(id).is_some_and(|s| s.locked)).map(|(id, _)| id.clone()).collect());
+    }
+    if st.formatting && st.show_styles {
+        let allowed = st.allowed.get_or_insert_with(Vec::new);
+        ui.label(egui::RichText::new(tl!("Checked styles are allowed:")).small());
+        ui.horizontal(|ui| {
+            if ui.small_button(tl!("All")).clicked() {
+                *allowed = styles.iter().map(|(id, _)| id.clone()).collect();
+            }
+            if ui.small_button(tl!("None")).clicked() {
+                allowed.clear();
+            }
+        });
+        egui::ScrollArea::vertical().id_salt("restrict_styles").max_height(160.0).show(ui, |ui| {
+            for (id, name) in &styles {
+                let mut on = allowed.contains(id);
+                if ui.checkbox(&mut on, tl!(name.as_str())).changed() {
+                    if on {
+                        allowed.push(id.clone());
+                    } else {
+                        allowed.retain(|x| x != id);
+                    }
+                }
+            }
+        });
+    }
+    heading(ui, "2. Editing restrictions");
+    ui.checkbox(&mut st.editing, tl!("Only allow this kind of editing:"));
+    ui.add_enabled_ui(st.editing, |ui| {
+        let current = EDIT_MODES.get(st.mode).map(|m| m.1).unwrap_or("");
+        egui::ComboBox::from_id_salt("restrict_mode").selected_text(tl!(current)).width(220.0).show_ui(ui, |ui| {
+            for (i, (_, label)) in EDIT_MODES.iter().enumerate() {
+                ui.selectable_value(&mut st.mode, i, tl!(label));
+            }
+        });
+    });
+    let mode = EDIT_MODES.get(st.mode).map(|m| m.0).unwrap_or("readOnly");
+    if st.editing && matches!(mode, "readOnly" | "comments") {
+        heading(ui, "Exceptions (optional)");
+        ui.label(egui::RichText::new(tl!("Select text, then tick who can still edit it.")).small());
+        let (a, b) = app.session.sel.ordered();
+        let inside = app.session.doc.perm_ranges().iter().any(|r| r.everyone() && r.start <= a && b <= r.end && r.start.story == a.story);
+        let mut everyone = inside;
+        let can = inside || a != b;
+        if ui.add_enabled(can, egui::Checkbox::new(&mut everyone, tl!("Everyone"))).changed() {
+            let p = if everyone { json!({"exception": "add"}) } else { json!({"exception": "remove"}) };
+            if let Err(e) = app.run("review.restrict", p) {
+                st.message = e;
+            }
+        }
+    }
+    heading(ui, "3. Start enforcement");
+    let ready = st.formatting || st.editing;
+    if !st.asking {
+        if ui.add_enabled(ready, egui::Button::new(tl!("Start Enforcing Protection"))).clicked() {
+            st.asking = true;
+            st.message.clear();
+        }
+    } else {
+        ui.label(egui::RichText::new(tl!("The password is optional; without it anyone can stop the protection.")).small());
+        passwords(ui, st, true);
+        ui.horizontal(|ui| {
+            if ui.button(tl!("OK")).clicked() {
+                if st.password != st.confirm {
+                    st.message = tl!("The passwords don't match.").to_string();
+                    st.confirm.as_mut_string().clear();
+                } else {
+                    let mut p =
+                        json!({"mode": if st.editing { mode } else { "none" }, "formatting": st.formatting, "password": st.password.as_str()});
+                    if st.formatting {
+                        let allowed = st.allowed.clone().unwrap_or_default();
+                        p["lockedStyles"] =
+                            json!(styles.iter().filter(|(id, _)| !allowed.contains(id)).map(|(id, _)| id.clone()).collect::<Vec<_>>());
+                    }
+                    match app.run("review.restrict", p) {
+                        Ok(_) => {
+                            st.asking = false;
+                            st.message.clear();
+                        }
+                        Err(e) => st.message = e,
+                    }
+                    st.password = Password::default();
+                    st.confirm = Password::default();
+                }
+            }
+            if ui.button(tl!("Cancel")).clicked() {
+                st.asking = false;
+                st.password = Password::default();
+                st.confirm = Password::default();
+            }
+        });
+    }
+    error(ui, &st.message);
+}
+
+fn passwords(ui: &mut Ui, st: &mut RestrictPane, confirm: bool) {
+    egui::Grid::new("restrict_pw").num_columns(2).spacing(vec2(8.0, 4.0)).show(ui, |ui| {
+        ui.label(tl!("Password:"));
+        ui.add(egui::TextEdit::singleline(st.password.as_mut_string()).password(true).desired_width(140.0));
+        ui.end_row();
+        if confirm {
+            ui.label(tl!("Confirm password:"));
+            ui.add(egui::TextEdit::singleline(st.confirm.as_mut_string()).password(true).desired_width(140.0));
+            ui.end_row();
+        }
+    });
+}
+
+fn enforced_ui(app: &mut WordApp, ui: &mut Ui, st: &mut RestrictPane, mode: &str) {
+    ui.label(tl!("Editing in this document is restricted."));
+    ui.add_space(4.0);
+    let what = match mode {
+        "readOnly" => "The document is read only, except for regions marked editable.",
+        "comments" => "Only comments can be added, except in regions marked editable.",
+        "trackedChanges" => "Every change is recorded as a tracked change.",
+        "forms" => "Only form fields can be filled in.",
+        _ => "Only the allowed styles can be applied.",
+    };
+    ui.label(egui::RichText::new(tl!(what)).small());
+    let regions = app.session.doc.perm_ranges().iter().filter(|r| r.everyone() || r.editor.eq_ignore_ascii_case(&app.session.author)).count();
+    if regions > 0 {
+        ui.add_space(6.0);
+        if ui.button(tl!("Find Next Editable Region")).clicked() {
+            let from = app.session.sel.ordered().1;
+            if let Some((a, b)) = wordcraft_engine::cmd::protect::next_region(&app.session, &from) {
+                app.session.sel = wordcraft_engine::Selection { anchor: a, focus: b };
+                app.canvas.want_focus = true;
+            }
+        }
+    }
+    ui.add_space(10.0);
+    let has_password = !app.session.doc.settings.protect_hash.is_empty();
+    if !st.asking {
+        if ui.button(tl!("Stop Protection")).clicked() {
+            if has_password {
+                st.asking = true;
+                st.message.clear();
+            } else {
+                stop(app, st);
+            }
+        }
+    } else {
+        ui.label(egui::RichText::new(tl!("Type the password to stop the protection.")).small());
+        passwords(ui, st, false);
+        ui.horizontal(|ui| {
+            if ui.button(tl!("OK")).clicked() {
+                stop(app, st);
+            }
+            if ui.button(tl!("Cancel")).clicked() {
+                st.asking = false;
+                st.password = Password::default();
+            }
+        });
+    }
+    error(ui, &st.message);
+}
+
+fn stop(app: &mut WordApp, st: &mut RestrictPane) {
+    let r = app.run("review.restrict", json!({"stop": true, "password": st.password.as_str()}));
+    st.password = Password::default();
+    match r {
+        Ok(_) => {
+            st.asking = false;
+            st.message.clear();
+        }
+        Err(e) if e.contains(wordcraft_engine::cmd::protect::UNSUPPORTED_PASSWORD) => {
+            st.message = tl!("This password type isn't supported.").to_string();
+        }
+        Err(e) => st.message = e,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+    use wordcraft_engine::Session;
+
+    use super::*;
+    use crate::{Services, WordApp};
+
+    fn app(text: &str) -> WordApp {
+        WordApp::new(Session::new(wordcraft_doc::Document::from_text(text)), Services::default())
+    }
+
+    #[test]
+    fn autocorrect_entries_persist_in_prefs_and_junk_is_ignored() {
+        let mut a = app("");
+        a.run("tools.autocorrect", json!({"add": {"from": "brb", "to": "be right back"}, "capDays": false})).unwrap();
+        let saved = serde_json::to_string(&a.prefs()).unwrap();
+        let mut b = app("");
+        b.apply_prefs(serde_json::from_str(&saved).unwrap());
+        assert_eq!(b.session.prefs.autocorrect.replacement("brb").as_deref(), Some("be right back"));
+        assert!(!b.session.prefs.autocorrect.cap_days);
+        for c in "brb ".chars() {
+            b.session.run("text.insert", &json!({"text": c.to_string()})).unwrap();
+        }
+        assert_eq!(b.session.doc.plain_text(wordcraft_doc::StoryRef::Body), "Be right back ");
+        // A damaged AutoCorrect section reads as the defaults; the rest of the file still loads.
+        let mut v: Value = serde_json::from_str(&saved).unwrap();
+        v["editing"]["autocorrect"] = json!({"entries": 7, "capDays": "x"});
+        v["author"] = json!("Ada");
+        let mut c = app("");
+        c.apply_prefs(serde_json::from_value(v).unwrap());
+        assert_eq!(c.session.prefs.autocorrect, AutoCorrectPrefs::default());
+        assert_eq!(c.session.author, "Ada");
+        // Hostile entries are dropped on load.
+        let mut v: Value = serde_json::from_str(&saved).unwrap();
+        v["editing"]["autocorrect"]["entries"] = json!([["", "x"], ["ok", "fine"], ["ok", "dup"], ["a\nb", "x"]]);
+        let mut d = app("");
+        d.apply_prefs(serde_json::from_value(v).unwrap());
+        assert_eq!(d.session.prefs.autocorrect.entries, vec![("ok".to_string(), "fine".to_string())]);
+    }
+
+    #[test]
+    fn dialogs_open_by_name_and_run_their_commands() {
+        let mut a = app("Original text.");
+        a.run("review.compare", json!({})).unwrap();
+        assert_eq!(a.dialog.as_ref().map(|d| d.name()), Some("compare"));
+        a.run("review.combine", json!({})).unwrap();
+        assert_eq!(a.dialog.as_ref().map(|d| d.name()), Some("combine"));
+        a.run("tools.autocorrect", json!({})).unwrap();
+        assert_eq!(a.dialog.as_ref().map(|d| d.name()), Some("autoCorrect"));
+        a.dialog = None;
+        // Restrict Editing without settings opens the pane and protects nothing.
+        a.run("review.restrict", json!({})).unwrap();
+        assert!(a.restrict.open && a.dialog.is_none());
+        assert!(a.session.doc.settings.protection.is_none());
+        // The form's parameters carry every comparison setting.
+        let mut f = CompareForm::new(&a, false);
+        assert!(f.params().is_none());
+        f.revised = "/tmp/revised.docx".into();
+        f.settings[3] = false;
+        let p = f.params().unwrap();
+        assert_eq!(p["caseChanges"], false);
+        assert_eq!(p["showIn"], "new");
+        assert!(p.get("original").is_none());
+    }
+}
diff --git a/crates/ui-egui/src/dialogs_smart_art.rs b/crates/ui-egui/src/dialogs_smart_art.rs
new file mode 100644
index 0000000000..b5df9c4ecd
--- /dev/null
+++ b/crates/ui-egui/src/dialogs_smart_art.rs
@@ -0,0 +1,340 @@
+//! Insert › SmartArt (a picker of layouts by category, with previews drawn in code) and the
+//! SmartArt Text Pane (the selected graphic's items as an editable outline). Each change runs one
+//! command (`insert.smartArt`, `smartArt.items`, `smartArt.addShape`…), so agents get the same
+//! result without the UI. The picker is shown through [`crate::dialogs_insert::InsertDialog`];
+//! the pane through [`crate::panes`].
+
+use egui::{Color32, Painter, Rect, Sense, Stroke, Ui, pos2, vec2};
+use serde::Serialize;
+use serde_json::{Value, json};
+use wordcraft_doc::props::Rgb;
+use wordcraft_doc::smart_art::{MAX_ITEMS, SmartArtColors, SmartArtLayout, SmartArtSpec};
+
+use crate::WordApp;
+use crate::theme::{Tokens, c32, regular, semibold};
+
+/// The picker's categories (`All` first), in the order shown.
+pub const CATEGORIES: [&str; 8] = ["All", "List", "Process", "Cycle", "Hierarchy", "Relationship", "Matrix", "Pyramid"];
+
+/// Insert › SmartArt: the category shown and the layout picked.
+#[derive(Clone, Debug, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct SmartArtForm {
+    pub category: String,
+    pub layout: SmartArtLayout,
+}
+
+impl SmartArtForm {
+    pub fn new(_app: &WordApp) -> SmartArtForm {
+        SmartArtForm { category: "All".into(), layout: SmartArtLayout::default() }
+    }
+
+    /// The layouts the current category shows.
+    pub fn shown(&self) -> Vec<SmartArtLayout> {
+        SmartArtLayout::ALL.into_iter().filter(|l| self.category == "All" || l.category() == self.category).collect()
+    }
+}
+
+/// Theme accent `n` (1–6) of the document.
+pub fn accent(theme: &[Rgb], n: usize) -> Color32 {
+    theme.get(3 + n.clamp(1, 6)).map(|c| c32(*c)).unwrap_or(Color32::from_rgb(0x15, 0x60, 0x82))
+}
+
+/// A small picture of `layout` in `r`, in the colours `colors` takes from `theme`; connector
+/// lines in `line`.
+pub fn preview(p: &Painter, r: Rect, layout: SmartArtLayout, colors: SmartArtColors, theme: &[Rgb], line: Color32) {
+    let r = r.shrink(r.width().min(r.height()) * 0.08);
+    let s = r.width().min(r.height());
+    let c = r.center();
+    let col = |i: usize| accent(theme, colors.accent(i));
+    // Unit-square coordinates (of the square in the middle of `r`) to screen.
+    let at = |x: f32, y: f32| pos2(c.x + (x - 0.5) * s, c.y + (y - 0.5) * s);
+    let block = |x0: f32, y0: f32, x1: f32, y1: f32, k: usize, round: f32| p.rect_filled(Rect::from_min_max(at(x0, y0), at(x1, y1)), round, col(k));
+    let thin = Stroke::new(1.0, line);
+    match layout {
+        SmartArtLayout::BasicList => {
+            for (k, (x, y)) in [(0.0, 0.18), (0.35, 0.18), (0.7, 0.18), (0.175, 0.55), (0.525, 0.55)].into_iter().enumerate() {
+                block(x, y, x + 0.3, y + 0.27, k, 0.0);
+            }
+        }
+        SmartArtLayout::Process => {
+            for k in 0..3 {
+                let x = k as f32 * 0.37;
+                block(x, 0.36, x + 0.26, 0.64, k, 3.0);
+                if k < 2 {
+                    let ax = x + 0.285;
+                    p.add(egui::Shape::convex_polygon(
+                        vec![at(ax, 0.45), at(ax + 0.06, 0.5), at(ax, 0.55)],
+                        col(k).gamma_multiply(0.6),
+                        Stroke::NONE,
+                    ));
+                }
+            }
+        }
+        SmartArtLayout::Cycle => {
+            p.circle_stroke(c, s * 0.34, thin);
+            for k in 0..5 {
+                let a = (-90.0 + 72.0 * k as f32).to_radians();
+                p.circle_filled(c + vec2(a.cos(), a.sin()) * s * 0.34, s * 0.12, col(k));
+            }
+        }
+        SmartArtLayout::Hierarchy => {
+            p.line_segment([at(0.5, 0.3), at(0.5, 0.45)], thin);
+            p.line_segment([at(0.17, 0.45), at(0.83, 0.45)], thin);
+            for x in [0.17, 0.5, 0.83] {
+                p.line_segment([at(x, 0.45), at(x, 0.6)], thin);
+            }
+            block(0.33, 0.08, 0.67, 0.3, 0, 3.0);
+            for (k, x) in [0.02, 0.35, 0.68].into_iter().enumerate() {
+                block(x, 0.6, x + 0.3, 0.82, k + 1, 3.0);
+            }
+        }
+        SmartArtLayout::Pyramid => {
+            // Half the pyramid's width at height `y` (apex at 0.05, base at 0.95).
+            let hw = |y: f32| 0.45 * (y - 0.05) / 0.9;
+            for (k, (y0, y1)) in [(0.05, 0.37), (0.37, 0.66), (0.66, 0.95)].into_iter().enumerate() {
+                let pts = if k == 0 {
+                    vec![at(0.5, y0), at(0.5 + hw(y1), y1), at(0.5 - hw(y1), y1)]
+                } else {
+                    vec![at(0.5 - hw(y0), y0), at(0.5 + hw(y0), y0), at(0.5 + hw(y1), y1), at(0.5 - hw(y1), y1)]
+                };
+                p.add(egui::Shape::convex_polygon(pts, col(k), Stroke::new(1.0, Color32::WHITE)));
+            }
+        }
+        SmartArtLayout::Radial => {
+            let spokes: Vec<egui::Pos2> = (0..4)
+                .map(|k| {
+                    let a = (-90.0 + 90.0 * k as f32).to_radians();
+                    c + vec2(a.cos(), a.sin()) * s * 0.36
+                })
+                .collect();
+            for q in &spokes {
+                p.line_segment([c, *q], thin);
+            }
+            p.circle_filled(c, s * 0.17, col(0));
+            for (k, q) in spokes.into_iter().enumerate() {
+                p.circle_filled(q, s * 0.12, col(k + 1));
+            }
+        }
+        SmartArtLayout::Matrix => {
+            for k in 0..4 {
+                let (x, y) = ((k % 2) as f32 * 0.5 + 0.03, (k / 2) as f32 * 0.5 + 0.03);
+                block(x, y, x + 0.44, y + 0.44, k, 3.0);
+            }
+        }
+        SmartArtLayout::Venn => {
+            for k in 0..3 {
+                let a = (-90.0 + 120.0 * k as f32).to_radians();
+                let q = c + vec2(a.cos(), a.sin()) * s * 0.15;
+                p.circle_filled(q, s * 0.3, col(k).gamma_multiply(0.5));
+                p.circle_stroke(q, s * 0.3, Stroke::new(1.0, col(k)));
+            }
+        }
+    }
+}
+
+/// A colour variant's name in the interface language.
+pub fn colors_label(c: SmartArtColors) -> String {
+    match c {
+        SmartArtColors::Colorful => tl!("Colorful").to_string(),
+        _ => crate::i18n::fmt(tl!("Accent {n}"), &[("n", &c.accent(0).to_string())]),
+    }
+}
+
+/// Swatches of a colour variant in `r`: the accents its shapes take.
+pub fn swatches(p: &Painter, r: Rect, colors: SmartArtColors, theme: &[Rgb]) {
+    let n = if colors == SmartArtColors::Colorful { 5 } else { 3 };
+    let w = r.width() / n as f32;
+    for k in 0..n {
+        let cell = Rect::from_min_size(pos2(r.left() + k as f32 * w, r.top()), vec2(w - 2.0, r.height()));
+        p.rect_filled(cell, 2.0, accent(theme, colors.accent(k)));
+    }
+}
+
+/// The picker; returns true to close.
+pub fn picker_ui(app: &mut WordApp, ui: &mut Ui, f: &mut SmartArtForm) -> bool {
+    let t = Tokens::get(ui.ctx());
+    let theme = app.session.doc.settings.theme_colors.clone();
+    let mut chosen = None;
+    ui.horizontal_top(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(120.0);
+            for cat in CATEGORIES {
+                if ui.selectable_label(f.category == cat, tl!(cat)).clicked() {
+                    f.category = cat.to_string();
+                    if !f.shown().contains(&f.layout)
+                        && let Some(first) = f.shown().first()
+                    {
+                        f.layout = *first;
+                    }
+                }
+            }
+        });
+        ui.separator();
+        ui.vertical(|ui| {
+            ui.set_width(3.0 * 96.0 + 16.0);
+            ui.set_min_height(2.0 * 96.0 + 8.0);
+            egui::Grid::new("smart_art_layouts").spacing(vec2(8.0, 8.0)).show(ui, |ui| {
+                for (k, layout) in f.shown().into_iter().enumerate() {
+                    let (rect, resp) = ui.allocate_exact_size(vec2(96.0, 88.0), Sense::click());
+                    let on = f.layout == layout;
+                    let fill = if on {
+                        t.checked
+                    } else if resp.hovered() {
+                        t.hover
+                    } else {
+                        t.input
+                    };
+                    ui.painter().rect(rect, 4.0, fill, Stroke::new(1.0, if on { t.accent } else { t.border }), egui::StrokeKind::Inside);
+                    preview(
+                        ui.painter(),
+                        Rect::from_min_size(rect.min + vec2(14.0, 4.0), vec2(68.0, 62.0)),
+                        layout,
+                        SmartArtColors::default(),
+                        &theme,
+                        t.text_dim,
+                    );
+                    ui.painter().text(
+                        pos2(rect.center().x, rect.bottom() - 11.0),
+                        egui::Align2::CENTER_CENTER,
+                        tl!(layout.label()),
+                        regular(10.5),
+                        t.text,
+                    );
+                    let resp = resp.on_hover_text(tl!(layout.label()));
+                    if resp.clicked() {
+                        f.layout = layout;
+                    }
+                    if resp.double_clicked() {
+                        chosen = Some(layout);
+                    }
+                    if k % 3 == 2 {
+                        ui.end_row();
+                    }
+                }
+            });
+        });
+        ui.separator();
+        ui.vertical(|ui| {
+            ui.set_width(200.0);
+            let (rect, _) = ui.allocate_exact_size(vec2(200.0, 150.0), Sense::hover());
+            ui.painter().rect(rect, 4.0, t.input, Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
+            preview(ui.painter(), rect.shrink(10.0), f.layout, SmartArtColors::default(), &theme, t.text_dim);
+            ui.add_space(6.0);
+            ui.label(egui::RichText::new(tl!(f.layout.label())).font(semibold(13.0)));
+            ui.add(egui::Label::new(tl!(f.layout.description())).wrap());
+        });
+    });
+    let (ok, cancel) = crate::dialogs_insert::buttons(ui, "OK", "Cancel", true);
+    let Some(layout) = chosen.or(ok.then_some(f.layout)) else { return cancel };
+    app.run("insert.smartArt", json!({"layout": layout.id()})).is_ok() || cancel
+}
+
+/// The `smartArt.items` params for `g` with item `i`'s text replaced by `text`.
+pub fn items_with(g: &SmartArtSpec, i: usize, text: &str) -> Value {
+    let items: Vec<Value> =
+        g.items.iter().enumerate().map(|(j, it)| json!({"text": if j == i { text } else { it.text.as_str() }, "level": it.level})).collect();
+    json!({"items": items})
+}
+
+/// The `smartArt.items` params for `g` without item `i` (the items under it move up a level).
+pub fn items_without(g: &SmartArtSpec, i: usize) -> Value {
+    let under = g.descendants(i);
+    let items: Vec<Value> = g
+        .items
+        .iter()
+        .enumerate()
+        .filter(|(j, _)| *j != i)
+        .map(|(j, it)| json!({"text": it.text, "level": if under.contains(&j) { it.level.saturating_sub(1) } else { it.level }}))
+        .collect();
+    json!({"items": items})
+}
+
+/// The Text Pane: a row per item, indented by level. Typing changes the graphic as you go (one
+/// undo step per item typed in); Enter adds an item after the current one.
+pub fn text_pane(app: &mut WordApp, ui: &mut Ui) {
+    let Some(g) = wordcraft_engine::cmd::smart_art::selected_smart_art(&app.session) else { return };
+    let t = Tokens::get(ui.ctx());
+    ui.label(egui::RichText::new(tl!("One line per item. Enter adds an item.")).color(t.text_dim));
+    ui.add_space(4.0);
+    let focus_id = egui::Id::new("smart_art_focus");
+    let want_focus: Option<usize> = ui.data_mut(|d| d.remove_temp(focus_id));
+    let mut typed = false;
+    egui::ScrollArea::vertical().id_salt("smart_art_items").max_height((ui.available_height() - 40.0).max(60.0)).show(ui, |ui| {
+        for (i, it) in g.items.iter().enumerate() {
+            ui.horizontal(|ui| {
+                ui.add_space(f32::from(it.level) * 16.0);
+                ui.label(egui::RichText::new("•").color(t.text_dim));
+                let mut text = it.text.clone();
+                let r = ui.add(egui::TextEdit::singleline(&mut text).id_salt(("smart_art_item", i)).desired_width(f32::INFINITY));
+                if want_focus == Some(i) {
+                    r.request_focus();
+                }
+                if r.has_focus() || r.gained_focus() {
+                    app.smart_art_item = Some(i);
+                }
+                if r.changed() {
+                    typed = true;
+                    if app.smart_art_typing == Some(i) {
+                        app.session.join_next_undo();
+                    }
+                    if app.run("smartArt.items", items_with(&g, i, &text)).is_ok() {
+                        app.smart_art_typing = Some(i);
+                    }
+                }
+                if r.lost_focus() && ui.input(|inp| inp.key_pressed(egui::Key::Enter)) && g.items.len() < MAX_ITEMS {
+                    app.smart_art_typing = None;
+                    if app.run("smartArt.addShape", json!({"after": i})).is_ok() {
+                        // The new item comes after this one and the items under it.
+                        let next = g.descendants(i).end;
+                        app.smart_art_item = Some(next);
+                        ui.data_mut(|d| d.insert_temp(focus_id, next));
+                    }
+                }
+            });
+        }
+    });
+    if !typed && !ui.ctx().memory(|m| m.focused().is_some()) {
+        app.smart_art_typing = None;
+    }
+    ui.separator();
+    let current = app.smart_art_item.filter(|i| *i < g.items.len());
+    ui.horizontal_wrapped(|ui| {
+        let at = current.map_or(json!({}), |i| json!({"after": i}));
+        if ui.add_enabled(g.items.len() < MAX_ITEMS, egui::Button::new(tl!("Add"))).clicked() {
+            app.smart_art_typing = None;
+            let _ = app.run("smartArt.addShape", at);
+        }
+        let idx = current.map_or(json!({}), |i| json!({"index": i}));
+        if ui.button(tl!("Promote")).clicked() {
+            app.smart_art_typing = None;
+            let _ = app.run("smartArt.promote", idx.clone());
+        }
+        if ui.button(tl!("Demote")).clicked() {
+            app.smart_art_typing = None;
+            let _ = app.run("smartArt.demote", idx);
+        }
+        if ui.add_enabled(current.is_some() && g.items.len() > 1, egui::Button::new(tl!("Remove"))).clicked()
+            && let Some(i) = current
+        {
+            app.smart_art_typing = None;
+            if app.run("smartArt.items", items_without(&g, i)).is_ok() {
+                app.smart_art_item = i.checked_sub(1);
+            }
+        }
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn removing_an_item_lifts_the_items_under_it() {
+        let g = SmartArtSpec::sample(SmartArtLayout::Hierarchy);
+        let v = items_without(&g, 1);
+        let levels: Vec<u64> = v["items"].as_array().unwrap().iter().map(|i| i["level"].as_u64().unwrap()).collect();
+        assert_eq!(levels, [0, 1, 1, 2, 2]);
+        assert_eq!(items_with(&g, 0, "Boss")["items"][0]["text"], "Boss");
+    }
+}
diff --git a/crates/ui-egui/src/dialogs_templates.rs b/crates/ui-egui/src/dialogs_templates.rs
new file mode 100644
index 0000000000..474dc5a845
--- /dev/null
+++ b/crates/ui-egui/src/dialogs_templates.rs
@@ -0,0 +1,314 @@
+//! Templates and Add-ins (View › Templates) and the style Organizer (#377). Each button ends in
+//! one command (`tools.attachTemplate`, `tools.detachTemplate`, `tools.linkStyles`,
+//! `styles.copyFrom`, `styles.delete`, `styles.rename`), so agents get the same result without
+//! the dialogs.
+
+use egui::{Ui, vec2};
+use serde::Serialize;
+use serde_json::{Value, json};
+
+use crate::WordApp;
+use crate::dialogs::{Dialog, buttons};
+use crate::file_dialogs::{AfterPick, FileDialogRequest};
+use crate::theme::{Tokens, semibold};
+
+/// The Templates and Add-ins dialog's fields.
+#[derive(Clone, Debug, Serialize)]
+pub struct TemplatesForm {
+    pub path: String,
+    /// "Automatically update document styles" (`w:linkStyles`).
+    pub link: bool,
+    was_path: String,
+    was_link: bool,
+    pub message: String,
+}
+
+impl TemplatesForm {
+    pub fn read(app: &mut WordApp) -> TemplatesForm {
+        // A file picked for a dialog that has since closed doesn't belong to this one.
+        app.dialog_pick = None;
+        let s = &app.session.doc.settings;
+        let path = s.attached_template.clone().unwrap_or_default();
+        TemplatesForm { was_path: path.clone(), path, link: s.link_styles, was_link: s.link_styles, message: String::new() }
+    }
+
+    /// OK: attach (updating the styles now when they follow the template), detach, or just switch
+    /// the automatic update.
+    fn apply(&self, app: &mut WordApp) -> Result<(), String> {
+        let path = self.path.trim();
+        if path.is_empty() {
+            if !self.was_path.trim().is_empty() {
+                app.run("tools.detachTemplate", json!({}))?;
+            } else if self.link != self.was_link {
+                app.run("tools.linkStyles", json!({"value": self.link}))?;
+            }
+            return Ok(());
+        }
+        if path != self.was_path || self.link != self.was_link || self.link {
+            app.run("tools.attachTemplate", json!({"path": path, "linkStyles": self.link, "update": self.link}))?;
+        }
+        Ok(())
+    }
+}
+
+/// Whether this host shows a file picker whose answer comes back to the dialog (the web's picker
+/// opens what it picks instead).
+fn can_pick(app: &WordApp) -> bool {
+    app.services.open_async.is_none() && (app.services.file_dialog.is_some() || app.services.pick_open.is_some())
+}
+
+/// Ask for a template or document; the answer arrives in `app.dialog_pick`.
+fn pick(app: &mut WordApp) {
+    let _ = app.ask_file(FileDialogRequest::Open { purpose: "template".into() }, AfterPick::ForDialog);
+}
+
+/// Returns true to close.
+pub fn templates(app: &mut WordApp, ui: &mut Ui, f: &mut TemplatesForm) -> bool {
+    if let Some(p) = app.dialog_pick.take() {
+        f.path = p;
+    }
+    ui.label(egui::RichText::new(tl!("Document template:")).font(semibold(12.5)));
+    ui.horizontal(|ui| {
+        ui.add(egui::TextEdit::singleline(&mut f.path).desired_width(300.0));
+        if ui.add_enabled(can_pick(app), egui::Button::new(tl!("Attach…"))).clicked() {
+            pick(app);
+        }
+    });
+    ui.checkbox(&mut f.link, tl!("Automatically update document styles"));
+    ui.add_space(6.0);
+    let organizer = ui.button(tl!("Organizer…")).clicked();
+    if !f.message.is_empty() {
+        ui.add(egui::Label::new(egui::RichText::new(f.message.as_str()).small().color(ui.visuals().error_fg_color)).wrap());
+    }
+    let (ok, cancel) = buttons(ui, tl!("OK"));
+    if organizer {
+        let back = TemplatesForm { message: String::new(), ..f.clone() };
+        app.dialog = Some(Dialog::Organizer { form: Box::new(OrganizerForm::read(app, Some(back))) });
+        return true;
+    }
+    if ok && let Err(e) = f.apply(app) {
+        f.message = e;
+        return false;
+    }
+    ok || cancel
+}
+
+/// The Organizer's state: this document's styles on the left (read live), another document's or
+/// template's on the right.
+#[derive(Clone, Debug, Serialize)]
+pub struct OrganizerForm {
+    /// The other file (empty: none open).
+    pub file: String,
+    /// Its styles: (name, type).
+    pub other: Vec<(String, String)>,
+    /// Selected style id in this document.
+    pub left: String,
+    /// Selected style name in the other file.
+    pub right: String,
+    /// The new name being typed (Rename…).
+    pub rename: Option<String>,
+    pub message: String,
+    /// Templates and Add-ins, to go back to on Close.
+    back: Option<Box<TemplatesForm>>,
+}
+
+impl OrganizerForm {
+    /// Opens with the attached template (or the template typed in Templates and Add-ins) on the right.
+    pub fn read(app: &mut WordApp, back: Option<TemplatesForm>) -> OrganizerForm {
+        app.dialog_pick = None;
+        let file =
+            back.as_ref().map(|b| b.path.trim().to_string()).or_else(|| app.session.doc.settings.attached_template.clone()).unwrap_or_default();
+        let mut f = OrganizerForm {
+            file: String::new(),
+            other: Vec::new(),
+            left: String::new(),
+            right: String::new(),
+            rename: None,
+            message: String::new(),
+            back: back.map(Box::new),
+        };
+        if !file.is_empty() {
+            f.load(app, &file);
+        }
+        f
+    }
+
+    fn load(&mut self, app: &mut WordApp, path: &str) {
+        match app.session.run("styles.organizer", &json!({"path": path})) {
+            Ok(v) => {
+                let list = v.get("file").and_then(|f| f.get("styles")).and_then(Value::as_array).cloned().unwrap_or_default();
+                let s = |x: &Value, k: &str| x.get(k).and_then(Value::as_str).unwrap_or("").to_string();
+                self.other = list.iter().map(|x| (s(x, "name"), s(x, "type"))).collect();
+                self.file = path.to_string();
+                self.right.clear();
+                self.message.clear();
+            }
+            Err(e) => self.message = e.to_string(),
+        }
+    }
+}
+
+fn glyph(ty: &str) -> &'static str {
+    match ty {
+        "character" => "a",
+        "table" => "⊞",
+        "numbering" => "≡",
+        _ => "¶",
+    }
+}
+
+/// Returns true to close.
+pub fn organizer(app: &mut WordApp, ui: &mut Ui, f: &mut OrganizerForm) -> bool {
+    if let Some(p) = app.dialog_pick.take() {
+        f.load(app, &p);
+    }
+    let mine = wordcraft_engine::cmd::templates::style_list(&app.session.doc);
+    let mine = mine.as_array().cloned().unwrap_or_default();
+    let s = |x: &Value, k: &str| x.get(k).and_then(Value::as_str).unwrap_or("").to_string();
+    if !mine.iter().any(|x| s(x, "id") == f.left) {
+        f.left.clear();
+    }
+    let t = Tokens::get(ui.ctx());
+    let list_frame = |ui: &mut Ui, salt: &str, add: &mut dyn FnMut(&mut Ui)| {
+        egui::Frame::NONE.stroke(egui::Stroke::new(1.0, t.border)).inner_margin(4).show(ui, |ui| {
+            ui.set_width(220.0);
+            ui.set_height(240.0);
+            egui::ScrollArea::vertical().id_salt(salt).max_height(240.0).auto_shrink([false, false]).show(ui, |ui| add(ui));
+        });
+    };
+    let mut copy = false;
+    let mut delete = false;
+    let mut rename = false;
+    let mut browse = false;
+    let left_builtin = mine.iter().find(|x| s(x, "id") == f.left).is_none_or(|x| x.get("builtIn").and_then(Value::as_bool).unwrap_or(true));
+    ui.horizontal_top(|ui| {
+        ui.vertical(|ui| {
+            ui.label(egui::RichText::new(tl!("Document")).font(semibold(12.5)));
+            list_frame(ui, "organizer_mine", &mut |ui| {
+                for st in &mine {
+                    let id = s(st, "id");
+                    if ui.selectable_label(f.left == id, format!("{}  {}", glyph(&s(st, "type")), s(st, "name"))).clicked() {
+                        f.left = id;
+                        f.rename = None;
+                    }
+                }
+            });
+        });
+        ui.vertical(|ui| {
+            ui.add_space(60.0);
+            let w = vec2(96.0, 0.0);
+            copy = ui.add_enabled(!f.right.is_empty(), egui::Button::new(format!("◀ {}", tl!("Copy"))).min_size(w)).clicked();
+            delete = ui.add_enabled(!left_builtin, egui::Button::new(tl!("Delete")).min_size(w)).clicked();
+            rename = ui.add_enabled(!left_builtin, egui::Button::new(tl!("Rename…")).min_size(w)).clicked();
+        });
+        ui.vertical(|ui| {
+            let name = std::path::Path::new(&f.file).file_name().map(|n| n.to_string_lossy().to_string()).unwrap_or_else(|| "—".into());
+            ui.label(egui::RichText::new(name).font(semibold(12.5))).on_hover_text(f.file.as_str());
+            list_frame(ui, "organizer_other", &mut |ui| {
+                for (n, ty) in &f.other {
+                    if ui.selectable_label(f.right == *n, format!("{}  {n}", glyph(ty))).clicked() {
+                        f.right = n.clone();
+                    }
+                }
+            });
+            browse = ui.add_enabled(can_pick(app), egui::Button::new(tl!("Browse…"))).clicked();
+        });
+    });
+    if copy {
+        let r = app.run("styles.copyFrom", json!({"path": f.file, "styles": [f.right]}));
+        f.message = r.err().unwrap_or_default();
+    }
+    if delete {
+        let r = app.run("styles.delete", json!({"style": f.left}));
+        f.message = r.err().unwrap_or_default();
+        f.left.clear();
+    }
+    if rename {
+        f.rename = mine.iter().find(|x| s(x, "id") == f.left).map(|x| s(x, "name"));
+    }
+    if browse {
+        pick(app);
+    }
+    let mut renamed = false;
+    if let Some(new) = f.rename.as_mut() {
+        ui.add_space(6.0);
+        ui.horizontal(|ui| {
+            ui.label(tl!("Name:"));
+            let r = ui.add(egui::TextEdit::singleline(new).desired_width(220.0));
+            renamed = ui.button(tl!("OK")).clicked() || (r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)));
+        });
+    }
+    if renamed && let Some(new) = f.rename.take() {
+        let r = app.run("styles.rename", json!({"style": f.left, "name": new}));
+        f.message = r.err().unwrap_or_default();
+    }
+    if !f.message.is_empty() {
+        ui.add(egui::Label::new(egui::RichText::new(f.message.as_str()).small().color(ui.visuals().error_fg_color)).wrap());
+    }
+    // Escape while renaming only stops renaming.
+    if f.rename.is_some() && ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+        f.rename = None;
+        return false;
+    }
+    // Close (Escape too), in a row of its own so the dialog stays as tall as its lists.
+    ui.add_space(8.0);
+    let mut close = ui.input(|i| i.key_pressed(egui::Key::Escape));
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            close |= ui.add(egui::Button::new(egui::RichText::new(tl!("Close")).color(egui::Color32::WHITE)).fill(crate::theme::APP_COLOR)).clicked();
+        });
+    });
+    if close {
+        if let Some(back) = f.back.take() {
+            app.dialog = Some(Dialog::Templates { form: back });
+        }
+        return true;
+    }
+    false
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Services;
+    use wordcraft_engine::Session;
+
+    /// The ribbon button opens Templates and Add-ins; OK attaches the typed template; the
+    /// Organizer copies a style from it into the document and Close goes back.
+    #[test]
+    fn templates_dialog_attaches_and_organizer_copies() {
+        let dir = std::env::temp_dir().join(format!("wordcraft-ui-templates-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join("House.dotx");
+        let mut t = wordcraft_doc::Document::new();
+        t.styles.upsert(wordcraft_doc::styles::Style {
+            id: "Memo".into(),
+            name: "Memo".into(),
+            kind: wordcraft_doc::styles::StyleKind::Paragraph,
+            ..Default::default()
+        });
+        wordcraft_engine::io::save_path(&path, &t).unwrap();
+        let p = path.to_string_lossy().to_string();
+
+        let mut a = WordApp::new(Session::new(wordcraft_doc::Document::new()), Services::default());
+        assert_eq!(a.run("tools.templates", json!({})).unwrap(), json!({"pending": "templates"}));
+        let Some(Dialog::Templates { form }) = &mut a.dialog else { panic!("dialog") };
+        form.path = p.clone();
+        let form = form.clone();
+        form.apply(&mut a).unwrap();
+        assert_eq!(a.session.doc.settings.attached_template.as_deref(), Some(p.as_str()));
+
+        let mut org = OrganizerForm::read(&mut a, None);
+        assert!(org.other.iter().any(|(n, _)| n == "Memo"), "{:?}", org.other);
+        org.right = "Memo".into();
+        let r = a.run("styles.copyFrom", json!({"path": org.file, "styles": [org.right]}));
+        assert!(r.is_ok(), "{r:?}");
+        assert!(a.session.doc.styles.get("Memo").is_some());
+        // Agents and scripts get the state, never the dialog.
+        a.dialog = None;
+        assert_eq!(a.execute("tools.templates", json!({})).unwrap()["template"], json!(p));
+        assert!(a.dialog.is_none());
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}
diff --git a/crates/ui-egui/src/file_browser.rs b/crates/ui-egui/src/file_browser.rs
new file mode 100644
index 0000000000..c36864bfbc
--- /dev/null
+++ b/crates/ui-egui/src/file_browser.rs
@@ -0,0 +1,559 @@
+//! The built-in file browser (#576): Open, Save As, Export, Insert Picture and recipient lists
+//! when the system's file dialog can't be shown — a Linux desktop with neither a file chooser
+//! portal nor zenity (labwc, sway… with only xdg-desktop-portal-wlr) — or when the user asks for
+//! it (File › Open › Browse in WordCraft…).
+//!
+//! A folder path field with Up and Home folder, the folder's subfolders and the files of the
+//! chosen type, a file name field and the file types. It only lists folders the user navigates to
+//! and never reads a file: the picked path goes to the same follow-up as the system dialog's.
+
+use std::path::{Path, PathBuf};
+
+use egui::{Align2, Rect, Sense, Ui, pos2, vec2};
+
+use crate::file_dialogs::{AfterPick, FileDialogRequest, open_filters};
+use crate::theme::{APP_COLOR, Tokens, regular};
+use crate::{WordApp, icons};
+
+/// At most this many entries are listed; a bigger folder shows the first ones and says so.
+const MAX_LISTED: usize = 5000;
+/// At most this many folder entries are read, so a huge folder can't stall the window.
+const MAX_SCANNED: usize = 100_000;
+const ROW: f32 = 24.0;
+
+/// The browser while it is open, and the folder it showed last (where it opens next time).
+#[derive(Default)]
+pub(crate) struct State {
+    pub(crate) open: Option<Box<FileBrowser>>,
+    last_dir: Option<PathBuf>,
+}
+
+/// One subfolder or file in the listing.
+#[derive(Clone, Debug, PartialEq)]
+pub(crate) struct Entry {
+    /// The name as shown (a name that isn't valid UTF-8 is shown with replacement characters).
+    pub(crate) name: String,
+    pub(crate) path: PathBuf,
+    pub(crate) dir: bool,
+}
+
+/// A folder's subfolders (first) and files, by name.
+#[derive(Debug, Default)]
+pub(crate) struct Listing {
+    pub(crate) entries: Vec<Entry>,
+    /// The folder holds more than was listed.
+    pub(crate) truncated: bool,
+}
+
+/// Whether `path` has one of `exts` (case-insensitive); `*` takes any file.
+pub(crate) fn matches(path: &Path, exts: &[String]) -> bool {
+    exts.iter().any(|e| e == "*") || path.extension().and_then(|e| e.to_str()).is_some_and(|e| exts.iter().any(|x| x.eq_ignore_ascii_case(e)))
+}
+
+/// The subfolders and the files with one of `exts` in `dir`, at most `cap` of them, folders first
+/// and each by name. Hidden entries (a leading dot) are left out; entries that can't be read are
+/// skipped.
+pub(crate) fn list_dir(dir: &Path, exts: &[String], cap: usize) -> std::io::Result<Listing> {
+    let mut listing = Listing::default();
+    for (i, item) in std::fs::read_dir(dir)?.enumerate() {
+        if i >= MAX_SCANNED {
+            listing.truncated = true;
+            break;
+        }
+        let Ok(item) = item else { continue };
+        let name = item.file_name().to_string_lossy().into_owned();
+        if name.starts_with('.') {
+            continue;
+        }
+        let path = item.path();
+        // A symbolic link to a folder is a folder.
+        let is_dir = match item.file_type() {
+            Ok(t) if t.is_symlink() => std::fs::metadata(&path).is_ok_and(|m| m.is_dir()),
+            Ok(t) => t.is_dir(),
+            Err(_) => continue,
+        };
+        if !is_dir && !matches(&path, exts) {
+            continue;
+        }
+        if listing.entries.len() >= cap {
+            listing.truncated = true;
+            break;
+        }
+        listing.entries.push(Entry { name, path, dir: is_dir });
+    }
+    listing.entries.sort_by_cached_key(|e| (!e.dir, e.name.to_lowercase()));
+    Ok(listing)
+}
+
+/// The user's home folder.
+pub(crate) fn home() -> Option<PathBuf> {
+    std::env::var_os("HOME").or_else(|| std::env::var_os("USERPROFILE")).filter(|h| !h.is_empty()).map(PathBuf::from)
+}
+
+/// What the user typed in the file name field, as a path: relative to `dir`, absolute, or under
+/// the home folder (`~/…`). `None` when nothing was typed.
+pub(crate) fn resolve(dir: &Path, typed: &str) -> Option<PathBuf> {
+    let typed = typed.trim();
+    if typed.is_empty() {
+        return None;
+    }
+    if typed == "~" {
+        return home();
+    }
+    if let Some(rest) = typed.strip_prefix("~/") {
+        return home().map(|h| h.join(rest));
+    }
+    Some(dir.join(typed))
+}
+
+/// What OK (or Enter, or a double click) did.
+#[derive(Debug, PartialEq)]
+pub(crate) enum Step {
+    /// The browser stays open (it moved to a folder, or has something to say).
+    Stay,
+    /// The file to open or save to.
+    Pick(PathBuf),
+}
+
+/// A message under the listing.
+#[derive(Clone, Debug, PartialEq)]
+enum Note {
+    None,
+    NotFound(String),
+    Replace(PathBuf),
+}
+
+/// The open browser.
+pub(crate) struct FileBrowser {
+    req: FileDialogRequest,
+    pub(crate) after: AfterPick,
+    /// Opened because the system dialog couldn't be shown: say why, and how to get it.
+    unavailable: bool,
+    dir: PathBuf,
+    /// The folder field (edited by the user, applied on Enter).
+    location: String,
+    /// The file name field.
+    pub(crate) name: String,
+    /// The file types, as (label, extensions).
+    filters: Vec<(String, Vec<String>)>,
+    filter: usize,
+    listing: Result<Listing, String>,
+    /// The highlighted entry.
+    selected: Option<PathBuf>,
+    note: Note,
+    focus_name: bool,
+}
+
+impl FileBrowser {
+    pub(crate) fn new(req: FileDialogRequest, after: AfterPick, start: PathBuf, unavailable: bool) -> Self {
+        let (name, filters) = match &req {
+            FileDialogRequest::Open { purpose } => {
+                (String::new(), open_filters(purpose).iter().map(|(l, e)| ((*l).to_string(), e.iter().map(|x| (*x).to_string()).collect())).collect())
+            }
+            FileDialogRequest::Save { name } => {
+                let ext = Path::new(name).extension().and_then(|e| e.to_str()).filter(|e| !e.is_empty());
+                let mut f: Vec<(String, Vec<String>)> = ext.map(|e| (format!("*.{e}"), vec![e.to_string()])).into_iter().collect();
+                f.push(("All files".into(), vec!["*".into()]));
+                (name.clone(), f)
+            }
+        };
+        let mut b = FileBrowser {
+            req,
+            after,
+            unavailable,
+            dir: start.clone(),
+            location: String::new(),
+            name,
+            filters,
+            filter: 0,
+            listing: Ok(Listing::default()),
+            selected: None,
+            note: Note::None,
+            focus_name: true,
+        };
+        b.navigate(start);
+        b
+    }
+
+    fn exts(&self) -> &[String] {
+        self.filters.get(self.filter).map_or(&[], |(_, e)| e.as_slice())
+    }
+
+    /// Show the folder `dir` (an unreadable folder shows why, and Up still works).
+    pub(crate) fn navigate(&mut self, dir: PathBuf) {
+        self.listing = list_dir(&dir, self.exts(), MAX_LISTED).map_err(|e| e.to_string());
+        self.location = dir.to_string_lossy().into_owned();
+        self.dir = dir;
+        self.selected = None;
+        self.note = Note::None;
+    }
+
+    fn up(&mut self) {
+        if let Some(parent) = self.dir.parent().map(Path::to_path_buf) {
+            self.navigate(parent);
+        }
+    }
+
+    /// OK: a highlighted folder, or a typed folder, is opened; otherwise the typed name is the
+    /// pick. Save adds the chosen type's extension to a name without one and asks once more
+    /// before replacing a file; Open wants a file that exists.
+    pub(crate) fn accept(&mut self) -> Step {
+        if let Some(dir) = self.selected.take().filter(|p| p.is_dir()) {
+            self.navigate(dir);
+            return Step::Stay;
+        }
+        let Some(mut path) = resolve(&self.dir, &self.name) else { return Step::Stay };
+        if path.is_dir() {
+            self.name.clear();
+            self.navigate(path);
+            return Step::Stay;
+        }
+        match self.req {
+            FileDialogRequest::Open { .. } => {
+                if path.is_file() {
+                    return Step::Pick(path);
+                }
+                self.note = Note::NotFound(self.name.trim().to_string());
+                Step::Stay
+            }
+            FileDialogRequest::Save { .. } => {
+                if path.extension().is_none()
+                    && let Some(ext) = self.exts().first().filter(|e| e.as_str() != "*")
+                {
+                    path.set_extension(ext);
+                }
+                if path.exists() && self.note != Note::Replace(path.clone()) {
+                    self.note = Note::Replace(path);
+                    return Step::Stay;
+                }
+                Step::Pick(path)
+            }
+        }
+    }
+
+    /// A click on an entry: highlight it, and a file's name goes into the file name field.
+    fn select(&mut self, e: &Entry) {
+        self.selected = Some(e.path.clone());
+        if !e.dir {
+            self.name = e.name.clone();
+        }
+        self.note = Note::None;
+    }
+
+    fn title(&self) -> &'static str {
+        match self.req {
+            FileDialogRequest::Open { .. } => "Open",
+            FileDialogRequest::Save { .. } => "Save As",
+        }
+    }
+
+    fn ok_label(&self) -> &'static str {
+        match self.req {
+            FileDialogRequest::Open { .. } => "Open",
+            FileDialogRequest::Save { .. } => "Save",
+        }
+    }
+}
+
+impl WordApp {
+    /// Ask for a file in the built-in browser and do `after` with the answer when it closes.
+    pub(crate) fn show_file_browser(&mut self, req: FileDialogRequest, after: AfterPick, unavailable: bool) {
+        let start = self
+            .file_browser
+            .last_dir
+            .clone()
+            .filter(|d| d.is_dir())
+            .or_else(|| self.session.path.as_ref().and_then(|p| p.parent()).map(Path::to_path_buf).filter(|d| d.is_dir()))
+            .or_else(home)
+            .or_else(|| std::env::current_dir().ok())
+            .unwrap_or_else(|| PathBuf::from("/"));
+        self.file_browser.open = Some(Box::new(FileBrowser::new(req, after, start, unavailable)));
+    }
+
+    /// `ui.fileBrowser`: the built-in browser for `purpose` (document, picture, recipients, save),
+    /// even when a system dialog was asked for and never showed up (it is given up as cancelled).
+    pub(crate) fn browse_builtin(&mut self, purpose: &str) {
+        self.give_up_file_dialog();
+        if self.file_browser.open.is_some() {
+            return;
+        }
+        let (req, after) = match purpose {
+            "picture" => (FileDialogRequest::Open { purpose: "picture".into() }, AfterPick::Picture),
+            "recipients" => (FileDialogRequest::Open { purpose: "recipients".into() }, AfterPick::Recipients),
+            "save" => (FileDialogRequest::Save { name: self.default_save_name() }, AfterPick::SaveAs(crate::file_dialogs::AfterSave::Nothing)),
+            _ => (FileDialogRequest::Open { purpose: "document".into() }, AfterPick::OpenDocument),
+        };
+        self.show_file_browser(req, after, false);
+    }
+
+    /// Close the browser with this answer (`None`: cancelled) and finish what it was for.
+    pub(crate) fn close_file_browser(&mut self, picked: Option<PathBuf>) {
+        let Some(b) = self.file_browser.open.take() else { return };
+        self.file_browser.last_dir = Some(b.dir.clone());
+        let picked = picked.map(|p| p.to_string_lossy().into_owned());
+        if let Err(e) = self.finish_pick(b.after, picked) {
+            log::warn!("file browser: {e}");
+        }
+        self.canvas.want_focus = true;
+    }
+}
+
+/// Draw the browser, if it is open.
+pub(crate) fn show(app: &mut WordApp, ctx: &egui::Context) {
+    let Some(mut b) = app.file_browser.open.take() else { return };
+    let t = Tokens::get(ctx);
+    let mut open = true;
+    let mut done: Option<Option<PathBuf>> = None;
+    egui::Window::new(tl!(b.title()))
+        .id(egui::Id::new("builtin_file_browser"))
+        .collapsible(false)
+        .resizable(false)
+        .anchor(Align2::CENTER_CENTER, vec2(0.0, -20.0))
+        .open(&mut open)
+        .show(ctx, |ui| {
+            ui.set_width(620.0);
+            done = body(ui, &mut b, &t);
+        });
+    if !open {
+        done = Some(None);
+    }
+    app.file_browser.open = Some(b);
+    if let Some(picked) = done {
+        app.close_file_browser(picked);
+    }
+}
+
+/// The browser's contents; `Some` once it closes (`Some(None)`: cancelled).
+fn body(ui: &mut Ui, b: &mut FileBrowser, t: &Tokens) -> Option<Option<PathBuf>> {
+    if b.unavailable {
+        ui.label(
+            egui::RichText::new(tl!(
+                "The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity."
+            ))
+            .color(t.text_dim),
+        );
+        ui.add_space(6.0);
+    }
+    let mut location_done = false;
+    ui.horizontal(|ui| {
+        if icon_button(ui, t, "chevronUp", tl!("Up one level"), b.dir.parent().is_some()) {
+            b.up();
+        }
+        if icon_button(ui, t, "homeFolder", tl!("Home folder"), true)
+            && let Some(h) = home()
+        {
+            b.navigate(h);
+        }
+        let r = ui.add(egui::TextEdit::singleline(&mut b.location).desired_width(f32::INFINITY));
+        if r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
+            location_done = true;
+            let typed = b.location.clone();
+            if let Some(dir) = resolve(&b.dir, &typed) {
+                b.navigate(dir);
+            }
+        }
+    });
+    ui.add_space(4.0);
+    let mut pick = false;
+    let mut go: Option<PathBuf> = None;
+    let mut clicked: Option<Entry> = None;
+    egui::Frame::NONE.fill(t.input).stroke(egui::Stroke::new(1.0, t.input_border)).inner_margin(2.0).show(ui, |ui| {
+        let entries: &[Entry] = b.listing.as_ref().map(|l| l.entries.as_slice()).unwrap_or(&[]);
+        egui::ScrollArea::vertical().max_height(300.0).min_scrolled_height(300.0).auto_shrink([false, false]).show_rows(
+            ui,
+            ROW,
+            entries.len(),
+            |ui, range| {
+                for e in entries.get(range).unwrap_or(&[]) {
+                    let (r, resp) = ui.allocate_exact_size(vec2(ui.available_width(), ROW), Sense::click());
+                    if b.selected.as_ref() == Some(&e.path) {
+                        ui.painter().rect_filled(r, 2.0, t.checked);
+                    } else if resp.hovered() {
+                        ui.painter().rect_filled(r, 2.0, t.hover);
+                    }
+                    let icon = Rect::from_center_size(pos2(r.min.x + 14.0, r.center().y), vec2(18.0, 18.0));
+                    icons::paint(ui.painter(), icon, if e.dir { "folder" } else { "file" }, t.icon, t.accent);
+                    ui.painter().with_clip_rect(r).text(pos2(r.min.x + 30.0, r.center().y), Align2::LEFT_CENTER, &e.name, regular(13.0), t.text);
+                    if resp.double_clicked() {
+                        if e.dir {
+                            go = Some(e.path.clone());
+                        } else {
+                            clicked = Some(e.clone());
+                            pick = true;
+                        }
+                    } else if resp.clicked() {
+                        clicked = Some(e.clone());
+                    }
+                }
+            },
+        );
+    });
+    if let Some(e) = clicked {
+        b.select(&e);
+    }
+    if let Some(dir) = go {
+        b.navigate(dir);
+    }
+    let message = match (&b.listing, &b.note) {
+        (_, Note::NotFound(name)) => Some((crate::i18n::fmt(tl!("{name} wasn't found."), &[("name", name)]), t.red)),
+        (_, Note::Replace(p)) => {
+            let name = p.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
+            Some((crate::i18n::fmt(tl!("{name} already exists. Choose Save again to replace it."), &[("name", &name)]), t.red))
+        }
+        (Err(e), _) => Some((crate::i18n::fmt(tl!("This folder can't be read: {error}"), &[("error", e)]), t.red)),
+        (Ok(l), _) if l.truncated => {
+            Some((crate::i18n::fmt(tl!("Showing the first {count} items."), &[("count", &l.entries.len().to_string())]), t.text_dim))
+        }
+        _ => None,
+    };
+    if let Some((text, color)) = message {
+        ui.label(egui::RichText::new(text).color(color));
+    }
+    ui.add_space(6.0);
+    let mut refilter = false;
+    ui.horizontal(|ui| {
+        let label = ui.label(tl!("File name:"));
+        // The name field takes what the label (longer in some languages) and the type list leave.
+        let width = (ui.available_width() - 170.0).max(120.0);
+        let r = ui.add(egui::TextEdit::singleline(&mut b.name).desired_width(width)).labelled_by(label.id);
+        if b.focus_name {
+            r.request_focus();
+            b.focus_name = false;
+        }
+        if r.changed() {
+            b.selected = None;
+            b.note = Note::None;
+        }
+        let before = b.filter;
+        let current = b.filters.get(b.filter).map(|(l, _)| tl!(l.as_str()).to_string()).unwrap_or_default();
+        egui::ComboBox::from_id_salt("builtin_file_browser_type").selected_text(current).width(150.0).show_ui(ui, |ui| {
+            for (i, (l, _)) in b.filters.iter().enumerate() {
+                ui.selectable_value(&mut b.filter, i, tl!(l.as_str()));
+            }
+        });
+        refilter = b.filter != before;
+    });
+    if refilter {
+        b.navigate(b.dir.clone());
+    }
+    ui.add_space(8.0);
+    let mut cancel = ui.input(|i| i.key_pressed(egui::Key::Escape));
+    let enter = !location_done && ui.input(|i| i.key_pressed(egui::Key::Enter));
+    ui.horizontal(|ui| {
+        ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
+            cancel |= ui.button(tl!("Cancel")).clicked();
+            let ok = ui.add(egui::Button::new(egui::RichText::new(tl!(b.ok_label())).color(egui::Color32::WHITE)).fill(APP_COLOR));
+            pick |= ok.clicked() || enter;
+        });
+    });
+    if cancel {
+        return Some(None);
+    }
+    if pick && let Step::Pick(path) = b.accept() {
+        return Some(Some(path));
+    }
+    None
+}
+
+/// A small button with a drawn icon and a tooltip; true when clicked.
+fn icon_button(ui: &mut Ui, t: &Tokens, icon: &str, tip: &str, enabled: bool) -> bool {
+    let (r, resp) = ui.allocate_exact_size(vec2(28.0, 24.0), if enabled { Sense::click() } else { Sense::hover() });
+    if enabled && resp.hovered() {
+        ui.painter().rect_filled(r, 3.0, t.hover);
+    }
+    let c = if enabled { t.icon } else { t.text_disabled };
+    icons::paint(ui.painter(), Rect::from_center_size(r.center(), vec2(18.0, 18.0)), icon, c, if enabled { t.accent } else { c });
+    resp.on_hover_text(tip).clicked()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Services;
+    use serde_json::json;
+    use std::sync::mpsc::channel;
+    use wordcraft_engine::Session;
+
+    fn scratch(name: &str) -> PathBuf {
+        let dir = std::env::temp_dir().join(format!("wordcraft-ui-browser-{name}-{}", std::process::id()));
+        let _ = std::fs::remove_dir_all(&dir);
+        std::fs::create_dir_all(&dir).unwrap();
+        dir
+    }
+
+    fn exts(e: &[&str]) -> Vec<String> {
+        e.iter().map(|x| x.to_string()).collect()
+    }
+
+    /// Folders come first, then the files of the chosen type (any case), each by name; hidden
+    /// entries and other types are left out, and a big folder is cut off and says so.
+    #[test]
+    fn listing_filters_sorts_and_caps() {
+        let dir = scratch("list");
+        for f in ["b.docx", "A.DOCX", "notes.txt", ".hidden.docx", "c.docx"] {
+            std::fs::write(dir.join(f), b"x").unwrap();
+        }
+        std::fs::create_dir(dir.join("zeta")).unwrap();
+        std::fs::create_dir(dir.join(".git")).unwrap();
+        let l = list_dir(&dir, &exts(&["docx"]), 100).unwrap();
+        let names: Vec<&str> = l.entries.iter().map(|e| e.name.as_str()).collect();
+        assert_eq!(names, ["zeta", "A.DOCX", "b.docx", "c.docx"]);
+        assert!(!l.truncated);
+        assert_eq!(list_dir(&dir, &exts(&["*"]), 100).unwrap().entries.len(), 5);
+        let capped = list_dir(&dir, &exts(&["docx"]), 2).unwrap();
+        assert_eq!(capped.entries.len(), 2);
+        assert!(capped.truncated);
+        assert!(list_dir(&dir.join("missing"), &exts(&["*"]), 10).is_err(), "an unreadable folder is an error, not a panic");
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    /// Save As in the browser: a typed folder is opened, a bare name gets the type's extension,
+    /// and an existing file is replaced only on the second OK.
+    #[test]
+    fn save_adds_the_extension_and_asks_before_replacing() {
+        let dir = scratch("save");
+        std::fs::create_dir(dir.join("drafts")).unwrap();
+        std::fs::write(dir.join("drafts").join("old.docx"), b"x").unwrap();
+        let req = FileDialogRequest::Save { name: "Document1.docx".into() };
+        let mut b = FileBrowser::new(req, AfterPick::OpenDocument, dir.clone(), false);
+        b.name = "drafts".into();
+        assert_eq!(b.accept(), Step::Stay);
+        assert_eq!(b.dir, dir.join("drafts"));
+        b.name = "chapter".into();
+        assert_eq!(b.accept(), Step::Pick(dir.join("drafts").join("chapter.docx")));
+        b.name = "old".into();
+        assert_eq!(b.accept(), Step::Stay, "asks before replacing");
+        assert_eq!(b.accept(), Step::Pick(dir.join("drafts").join("old.docx")));
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
+    /// The host can't show a system dialog (#576): Save As carries on in the built-in browser,
+    /// and its answer saves the document.
+    #[test]
+    fn no_system_dialog_falls_back_to_the_built_in_browser() {
+        let dir = scratch("fallback");
+        let services = Services {
+            file_dialog: Some(Box::new(|_req| {
+                let (tx, rx) = channel();
+                tx.send(Err("no portal".to_string())).unwrap();
+                rx
+            })),
+            ..Default::default()
+        };
+        let mut a = WordApp::new(Session::new(wordcraft_doc::Document::new()), services);
+        a.run("text.insert", json!({"text": "Saved without a portal"})).unwrap();
+        a.save_as_dialog();
+        assert!(a.file_dialog_open());
+        let b = a.file_browser.open.as_mut().expect("the built-in browser is open");
+        assert!(b.unavailable);
+        b.navigate(dir.clone());
+        b.name = "novel".into();
+        let Step::Pick(path) = b.accept() else { panic!("picked") };
+        a.close_file_browser(Some(path));
+        assert!(!a.file_dialog_open());
+        assert!(!a.session.dirty);
+        let saved = wordcraft_engine::io::open_path(&dir.join("novel.docx")).unwrap();
+        assert!(saved.plain_text(wordcraft_doc::StoryRef::Body).contains("Saved without a portal"));
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+}
diff --git a/crates/ui-egui/src/file_dialogs.rs b/crates/ui-egui/src/file_dialogs.rs
index ea9c9b18fb..788f81b679 100644
--- a/crates/ui-egui/src/file_dialogs.rs
+++ b/crates/ui-egui/src/file_dialogs.rs
@@ -6,6 +6,10 @@
 //! pending New/Open/Close, export, insert the picture). A host with only the blocking
 //! `pick_open` / `pick_save` gets the same follow-up straight away. One dialog at a time: asking
 //! for another while one is open does nothing.
+//!
+//! When the host can't show a system dialog at all (a Linux desktop with neither a file chooser
+//! portal nor zenity, #576) it answers with an error, and the app finishes the job in its own
+//! [`file_browser`](crate::file_browser) instead.
 
 use std::sync::mpsc::{Receiver, TryRecvError};
 
@@ -16,13 +20,32 @@ use crate::WordApp;
 /// A file dialog the app asks the host to show ([`Services::file_dialog`](crate::Services::file_dialog)).
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub enum FileDialogRequest {
-    /// Pick a file to open; `purpose` says what for (`document`, `picture`, `recipients`), as for
+    /// Pick a file to open; `purpose` says what for (`document`, `picture`, `recipients`, `font`), as for
     /// `pick_open`.
     Open { purpose: String },
     /// Pick a path to save to, given a suggested file name.
     Save { name: String },
 }
 
+/// The host's answer to a [`FileDialogRequest`]: the picked path, `Ok(None)` when the user
+/// cancelled, or an error when no system dialog could be shown (the app then shows its own).
+pub type FileDialogAnswer = Result<Option<String>, String>;
+
+const PICTURES: &[&str] = &["png", "jpg", "jpeg", "gif", "webp", "bmp"];
+const DOCUMENTS: &[&str] = &["docx", "docm", "dotx", "dotm", "doc", "dot", "odt", "rtf", "txt", "md", "html", "htm", "tex", "json", "xml"];
+
+/// The file types Open offers, as (label, extensions; `*` is any file): pictures for Insert/Change
+/// Picture, recipient lists for Select Recipients › Use an Existing List…, documents otherwise.
+/// The host's system dialog and the built-in browser offer the same.
+pub fn open_filters(purpose: &str) -> &'static [(&'static str, &'static [&'static str])] {
+    match purpose {
+        "picture" => &[("Pictures", PICTURES)],
+        "font" => &[("Fonts", wordcraft_fonts::FONT_FILE_EXTS)],
+        "recipients" => &[("Recipient lists", &["csv", "tsv", "txt", "xlsx", "xlsm", "ods"]), ("All files", &["*"])],
+        _ => &[("Documents", DOCUMENTS), ("Word document", &["docx"]), ("All files", &["*"])],
+    }
+}
+
 /// What to do with the path picked in a dialog.
 pub(crate) enum AfterPick {
     /// Open the picked document.
@@ -33,8 +56,17 @@ pub(crate) enum AfterPick {
     SaveAs(AfterSave),
     /// Save a copy there in this format (`pdf`, `docx`, `png`…).
     Export { ext: String },
+    /// Write the PDF of these print settings there (File › Print › Save these pages as PDF).
+    PrintPdf { settings: Value },
     /// Load the picked CSV/TSV/text file or spreadsheet as the mail-merge recipients (#240, #334).
     Recipients,
+    /// Add the picked font file (#582).
+    Font,
+    /// Hand the picked path to the open dialog (`WordApp::dialog_pick`): Templates and Add-ins,
+    /// Organizer (#377).
+    ForDialog,
+    /// Put the picked document into the Compare dialog (original or revised, #412).
+    ComparePath { revised: bool },
 }
 
 /// What to do once Save As has written the document.
@@ -53,7 +85,8 @@ pub(crate) enum AfterSave {
 
 /// A dialog the host is showing; the answer arrives on `rx` (`None`: cancelled).
 pub(crate) struct PendingDialog {
-    rx: Receiver<Option<String>>,
+    rx: Receiver<FileDialogAnswer>,
+    req: FileDialogRequest,
     after: AfterPick,
 }
 
@@ -68,22 +101,32 @@ pub(crate) enum Asked {
 }
 
 impl WordApp {
-    /// Whether a file dialog is open (its answer hasn't arrived yet).
+    /// Whether a file dialog is open (its answer hasn't arrived yet), the host's or the built-in one.
     pub fn file_dialog_open(&self) -> bool {
-        self.file_dialog.is_some()
+        self.file_dialog.is_some() || self.file_browser_open()
+    }
+
+    #[cfg(not(target_arch = "wasm32"))]
+    fn file_browser_open(&self) -> bool {
+        self.file_browser.open.is_some()
+    }
+
+    #[cfg(target_arch = "wasm32")]
+    fn file_browser_open(&self) -> bool {
+        false
     }
 
     /// Ask the host for a file and do `after` with the answer: now for a blocking dialog, on a
     /// later frame for an asynchronous one. Ignored while another dialog is open.
     pub(crate) fn ask_file(&mut self, req: FileDialogRequest, after: AfterPick) -> Asked {
-        if self.file_dialog.is_some() {
+        if self.file_dialog_open() {
             log::debug!("file dialog already open; ignoring {req:?}");
             self.status(tl!("A file dialog is already open."));
             return Asked::Busy;
         }
         if let Some(show) = &self.services.file_dialog {
-            let rx = show(req);
-            self.file_dialog = Some(PendingDialog { rx, after });
+            let rx = show(req.clone());
+            self.file_dialog = Some(PendingDialog { rx, req, after });
             // A host that answered at once (or failed to show anything) is handled right away.
             return self.poll_file_dialog().map_or(Asked::Pending, Asked::Done);
         }
@@ -97,18 +140,46 @@ impl WordApp {
     /// Pick up the answer of an open file dialog, if it has arrived (every frame, from `logic`),
     /// and finish what it was for. `None` while there is nothing to finish.
     pub(crate) fn poll_file_dialog(&mut self) -> Option<Result<Value, String>> {
-        let picked = match self.file_dialog.as_ref().map(|d| d.rx.try_recv()) {
+        let answer = match self.file_dialog.as_ref().map(|d| d.rx.try_recv()) {
             None | Some(Err(TryRecvError::Empty)) => return None,
-            Some(Ok(picked)) => picked,
+            Some(Ok(answer)) => answer,
             // The host dropped the dialog without an answer: as good as cancelled.
-            Some(Err(TryRecvError::Disconnected)) => None,
+            Some(Err(TryRecvError::Disconnected)) => Ok(None),
         };
         let d = self.file_dialog.take()?;
-        Some(self.finish_pick(d.after, picked))
+        match answer {
+            Ok(picked) => Some(self.finish_pick(d.after, picked)),
+            Err(reason) => {
+                log::warn!("no system file dialog ({reason}); showing the built-in file browser");
+                self.dialog_unavailable(d.req, d.after)
+            }
+        }
+    }
+
+    /// Treat the system dialog the host is showing as cancelled, e.g. one that never showed up.
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(crate) fn give_up_file_dialog(&mut self) {
+        if let Some(d) = self.file_dialog.take() {
+            let _ = self.finish_pick(d.after, None);
+        }
+    }
+
+    /// The host couldn't show a system dialog (#576): ask in the built-in browser instead, which
+    /// finishes the job later. `None` while it is open.
+    #[cfg(not(target_arch = "wasm32"))]
+    fn dialog_unavailable(&mut self, req: FileDialogRequest, after: AfterPick) -> Option<Result<Value, String>> {
+        self.show_file_browser(req, after, true);
+        None
+    }
+
+    /// The browser has no built-in file browser (it can't list the user's folders): cancelled.
+    #[cfg(target_arch = "wasm32")]
+    fn dialog_unavailable(&mut self, _req: FileDialogRequest, after: AfterPick) -> Option<Result<Value, String>> {
+        Some(self.finish_pick(after, None))
     }
 
     /// Do what the dialog was for with the picked path (`None`: the user cancelled).
-    fn finish_pick(&mut self, after: AfterPick, picked: Option<String>) -> Result<Value, String> {
+    pub(crate) fn finish_pick(&mut self, after: AfterPick, picked: Option<String>) -> Result<Value, String> {
         match after {
             AfterPick::OpenDocument => {
                 let Some(path) = picked else { return Ok(json!({"cancelled": true})) };
@@ -123,10 +194,25 @@ impl WordApp {
                 };
                 self.insert_or_change_picture(json!({"path": path}))
             }
+            AfterPick::Font => {
+                let Some(path) = picked else { return Ok(json!({"cancelled": true})) };
+                self.run("font.add", json!({"path": path}))
+            }
+            AfterPick::ForDialog => {
+                let picked = picked.filter(|p| !p.is_empty());
+                let r = json!({"picked": picked});
+                self.dialog_pick = picked;
+                Ok(r)
+            }
             AfterPick::Recipients => {
                 let Some(path) = picked else { return Ok(json!({"cancelled": true})) };
                 self.load_recipients(json!({"path": path}))
             }
+            AfterPick::ComparePath { revised } => {
+                let Some(path) = picked else { return Ok(json!({"cancelled": true})) };
+                crate::dialogs_review::set_compare_path(self, revised, path);
+                Ok(json!({"picked": true}))
+            }
             AfterPick::Export { ext } => {
                 let Some(path) = picked else { return Ok(json!({"cancelled": true})) };
                 let r = if ext == "png" { self.run("file.exportPng", json!({"path": path})) } else { self.run("file.saveAs", json!({"path": path})) };
@@ -135,6 +221,16 @@ impl WordApp {
                 }
                 r
             }
+            AfterPick::PrintPdf { settings } => {
+                let Some(path) = picked else { return Ok(json!({"cancelled": true})) };
+                let mut params = settings;
+                params["path"] = json!(path);
+                let r = self.run("file.printPdf", params);
+                if r.is_ok() {
+                    self.status(crate::i18n::fmt(tl!("Exported {path}"), &[("path", &path)]));
+                }
+                r
+            }
             AfterPick::SaveAs(after) => {
                 let saved = picked.is_some_and(|path| {
                     self.run("file.save", json!({"path": path})).is_ok_and(|v| v.get("saved").and_then(Value::as_bool) == Some(true))
@@ -175,6 +271,14 @@ impl WordApp {
         let _ = self.ask_file(FileDialogRequest::Save { name }, AfterPick::Export { ext: ext.to_string() });
     }
 
+    /// File › Print › Save these pages as PDF: ask where, then write the pages the print
+    /// settings choose.
+    pub(crate) fn print_pdf_dialog(&mut self) {
+        let name = format!("{}.pdf", self.title_stem());
+        let settings = self.ui.print.params();
+        let _ = self.ask_file(FileDialogRequest::Save { name }, AfterPick::PrintPdf { settings });
+    }
+
     pub(crate) fn open_dialog(&mut self) {
         if let Some(f) = &self.services.open_async {
             f("document");
@@ -190,6 +294,15 @@ impl WordApp {
         }
         let _ = self.ask_file(FileDialogRequest::Open { purpose: "picture".into() }, AfterPick::Picture);
     }
+
+    /// Pick a font file to add (Add Font…; web: it arrives through the inbox).
+    pub(crate) fn pick_font(&mut self) {
+        if let Some(f) = &self.services.open_async {
+            f("font");
+            return;
+        }
+        let _ = self.ask_file(FileDialogRequest::Open { purpose: "font".into() }, AfterPick::Font);
+    }
 }
 
 #[cfg(test)]
@@ -205,7 +318,7 @@ mod tests {
     const UNSAVED: &str = "My unsaved novel chapter";
 
     /// Dialogs the fake host was asked to show, each with the channel its answer goes through.
-    type Shown = Rc<RefCell<Vec<(FileDialogRequest, Sender<Option<String>>)>>>;
+    type Shown = Rc<RefCell<Vec<(FileDialogRequest, Sender<FileDialogAnswer>)>>>;
 
     /// An app whose host shows dialogs asynchronously: nothing is answered until the test does.
     fn async_app() -> (WordApp, Shown) {
@@ -225,7 +338,7 @@ mod tests {
     /// Answer the dialog the host is showing (the last one asked for).
     fn answer(shown: &Shown, picked: Option<&str>) {
         let (_, tx) = shown.borrow_mut().pop().unwrap();
-        tx.send(picked.map(str::to_string)).unwrap();
+        tx.send(Ok(picked.map(str::to_string))).unwrap();
     }
 
     fn typed(a: &mut WordApp) {
@@ -270,6 +383,35 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
     }
 
+    /// #689: Save As honours the filename typed in the dialog, not just the folder: a document
+    /// opened as `a/one.docx` and saved as `b/two.docx` is written there and takes that path.
+    #[test]
+    fn save_as_with_a_new_filename_saves_under_it() {
+        let dir = scratch("rename");
+        let opened = dir.join("one.docx");
+        let picked = dir.join("sub").join("two.docx");
+        std::fs::create_dir_all(dir.join("sub")).unwrap();
+        wordcraft_engine::Session::new(wordcraft_doc::Document::from_text("original"))
+            .run("file.save", &json!({"path": opened.to_string_lossy()}))
+            .unwrap();
+        let (mut a, shown) = async_app();
+        a.run("file.open", json!({"path": opened.to_string_lossy()})).unwrap();
+        assert_eq!(a.session.path.as_deref(), Some(opened.as_path()));
+        a.save_as_dialog();
+        answer(&shown, Some(&picked.to_string_lossy()));
+        let r = a.poll_file_dialog().unwrap().unwrap();
+        assert_eq!(r, json!({"saved": true}), "the save-as succeeded");
+        assert_eq!(a.session.path.as_deref(), Some(picked.as_path()), "the picked filename is the document's path");
+        assert!(picked.is_file(), "the file is written under the picked name");
+        assert!(saved_text(&picked).contains("original"));
+        // F12 (file.saveAs without a path) lands in the same dialog, suggesting the new name.
+        let r = a.run("file.saveAs", json!({})).unwrap();
+        assert_eq!(r, json!({"saved": false}));
+        assert!(a.file_dialog_open(), "F12's saveAs request opens the dialog");
+        assert_eq!(shown.borrow()[0].0, FileDialogRequest::Save { name: "two.docx".into() });
+        let _ = std::fs::remove_dir_all(&dir);
+    }
+
     /// While a dialog is open, more Save As / Open / Export / Picture clicks don't open a second one.
     #[test]
     fn a_second_dialog_while_one_is_open_is_ignored() {
diff --git a/crates/ui-egui/src/i18n/audit.rs b/crates/ui-egui/src/i18n/audit.rs
index 714c12c9e2..bb13f09707 100644
--- a/crates/ui-egui/src/i18n/audit.rs
+++ b/crates/ui-egui/src/i18n/audit.rs
@@ -112,6 +112,20 @@ impl Exempt {
         names.extend(app.session.doc.styles.styles.iter().map(|s| s.name.clone()));
         // Fonts a document asks for, installed or not (Aptos is drawn with a substitute).
         names.extend([wordcraft_doc::styles::BODY_FONT, wordcraft_doc::styles::HEADING_FONT].map(str::to_string));
+        // The selected SmartArt graphic's items (the Text Pane): document content.
+        if let Some(g) = wordcraft_engine::cmd::smart_art::selected_smart_art(&app.session) {
+            names.extend(g.items.iter().map(|i| i.text.clone()));
+        }
+        // The accessibility checker's findings: like command messages, they answer scripts and
+        // MCP too, so they stay English for now.
+        for i in wordcraft_engine::cmd::accessibility::check(&app.session.doc) {
+            names.extend(["issue", "fix"].iter().filter_map(|k| i[*k].as_str()).map(str::to_string));
+        }
+        // The selected chart's data (Edit Data's grid): document content.
+        if let Some(c) = wordcraft_engine::cmd::chart::selected_chart(&app.session) {
+            names.extend(c.categories.iter().cloned());
+            names.extend(c.series.iter().map(|s| s.name.clone()));
+        }
         for m in crate::credits::MODELS {
             names.extend([m.company, m.model, m.version].map(str::to_string));
         }
@@ -142,6 +156,7 @@ impl Exempt {
             || plain.contains('┬') || plain.contains('\u{2061}') // equation input (UnicodeMath), drawn as math
             || matches!(plain, "WordCraft" | "WordCraft User" | "Discord" | "https://" | "auto" | "I. II. III." | "i. ii. iii.")
             || plain == "CONFIDENTIAL" // the watermark dialog's text: document content, kept as typed
+            || plain == "Figure 1" // the caption dialog's sample: the label goes into the document as is
     }
 }
 
@@ -172,6 +187,11 @@ fn untranslated_interface_text() {
         let drawn = frame(&ctx, &mut app);
         record(&app, &format!("File › {page}"), drawn);
     }
+    for pane in wordcraft_engine::cmd::options::PANES {
+        let _ = app.run("ui.backstage", json!({"value": true, "page": "options", "pane": pane}));
+        let drawn = frame(&ctx, &mut app);
+        record(&app, &format!("File › Options › {pane}"), drawn);
+    }
     let _ = app.run("ui.backstage", json!({"value": false}));
     let dialogs = [
         "font",
@@ -195,6 +215,12 @@ fn untranslated_interface_text() {
         "models",
         "insertMergeField",
         "findRecipient",
+        "caption",
+        "index",
+        "markEntry",
+        "toc",
+        "sourceManager",
+        "createSource",
     ];
     for name in dialogs {
         let _ = app.run("ui.dialog", json!({"name": name}));
@@ -221,6 +247,26 @@ fn untranslated_interface_text() {
         let drawn = frame(&ctx, &mut app);
         record(&app, &format!("tab {tab}"), drawn);
     }
+    let _ = app.run("insert.smartArt", json!({"layout": "hierarchy"}));
+    let _ = app.run("smartArt.textPane", json!({"value": true}));
+    let _ = app.run("ui.tab", json!({"tab": "SmartArt Design"}));
+    let drawn = frame(&ctx, &mut app);
+    record(&app, "tab SmartArt Design", drawn);
+    let _ = app.run("smartArt.textPane", json!({"value": false}));
+    let _ = app.run("ui.dialog", json!({"name": "insertSmartArt"}));
+    let drawn = frame(&ctx, &mut app);
+    record(&app, "dialog insertSmartArt", drawn);
+    app.dialog = None;
+    let _ = app.run("insert.chart", json!({"type": "column"}));
+    let _ = app.run("ui.tab", json!({"tab": "Chart Design"}));
+    let drawn = frame(&ctx, &mut app);
+    record(&app, "tab Chart Design", drawn);
+    for name in ["chartData", "changeChartType", "insertChart"] {
+        let _ = app.run("ui.dialog", json!({"name": name}));
+        let drawn = frame(&ctx, &mut app);
+        record(&app, &format!("dialog {name}"), drawn);
+        app.dialog = None;
+    }
     let _ = app.run("insert.equation", json!({}));
     let _ = app.run("ui.tab", json!({"tab": "Equation"}));
     let drawn = frame(&ctx, &mut app);
@@ -229,13 +275,15 @@ fn untranslated_interface_text() {
     // tab keeps one tab's commands from changing the next.
     // A fresh app per control, set up the same way, so no click changes what the next one hits
     // (Escape, for one, leaves an equation and takes the Equation tab with it).
-    let contextual = ["Table Design", "Table Layout", "Equation"];
+    let contextual = ["Table Design", "Table Layout", "Equation", "Chart Design", "SmartArt Design"];
     let open = |tab: &str| {
         let ctx = egui::Context::default();
         let mut app = fresh_app(&ctx);
         match tab {
             "Table Design" | "Table Layout" => drop(app.run("insert.table", json!({"rows": 2, "cols": 2}))),
             "Equation" => drop(app.run("insert.equation", json!({}))),
+            "SmartArt Design" => drop(app.run("insert.smartArt", json!({"layout": "process"}))),
+            "Chart Design" => drop(app.run("insert.chart", json!({"type": "column"}))),
             _ => {}
         }
         let _ = app.run("ui.tab", json!({"tab": tab}));
diff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsv
index 3b2d9d66bb..394322977c 100644
--- a/crates/ui-egui/src/i18n/es.tsv
+++ b/crates/ui-egui/src/i18n/es.tsv
@@ -62,6 +62,8 @@
 	Arrange\nAll	Organizar\ntodo
 	Arrow	Flecha
 	Artistic Effects	Efectos artísticos
+	As you type	Mientras escribes
+	Asian text font:	Fuente de texto asiático:
 	Asian Typography	Tipografía asiática
 	Author	Autor
 	AutoCorrect Options	Opciones de autocorrección
@@ -72,35 +74,73 @@
 	AutoSave saves every change to the file (needs a saved document)	El autoguardado guarda cada cambio en el archivo (requiere un documento guardado)
 	AutoSave isn't available in the browser: it can't write to your files. Save downloads a copy.	El autoguardado no está disponible en el navegador: no puede escribir en tus archivos. Guardar descarga una copia.
 	AutoSave only keeps .docx, .odt and .rtf files; {name} can't keep all formatting. Save as .docx to turn on AutoSave.	El autoguardado solo admite archivos .docx, .odt y .rtf; {name} no puede conservar todo el formato. Guarda como .docx para activar el autoguardado.
+	AutoSave writes your changes to the file a moment after you stop typing.	El autoguardado escribe tus cambios en el archivo poco después de que dejes de escribir.
 	Balloons	Globos
 	Bullet	Viñeta
 	By author	Por autor
+	Centimeters	Centímetros
 	Changed lines:	Líneas cambiadas:
 	Click level to modify:	Haz clic en el nivel que quieras modificar:
+	Check spelling as you type	Revisar la ortografía mientras escribes
+	Click to switch back to inserting	Haz clic para volver a insertar
 	Color only	Solo color
+	Custom dictionary	Diccionario personalizado
 	Define New Multilevel List	Definir nueva lista multinivel
 	Define New Multilevel List…	Definir nueva lista multinivel…
 	Deletions:	Eliminaciones:
 	Enter formatting for number:	Formato del número:
 	Follow number with:	Después del número:
 	Formatting	Formato
+	Formatting marks	Marcas de formato
+	Hidden text	Texto oculto
+	Ignore web and file addresses	Omitir direcciones web y de archivo
+	Ignore words in capitals	Omitir palabras en mayúsculas
+	Ignore words with numbers	Omitir palabras con números
+	Inches	Pulgadas
+	Formatting exceptions	Excepciones de formato
 	Include level number from:	Incluir número de nivel de:
+	Initials:	Iniciales:
 	Ink	Entrada de lápiz
 	Insertions and Deletions	Inserciones y eliminaciones
 	Insertions:	Inserciones:
+	Interface	Interfaz
+	Interface language	Idioma de la interfaz
+	Inside:	Interior:
+	Latin text font:	Fuente de texto latino:
 	Left border	Borde izquierdo
 	Legal style numbering	Numeración de estilo legal
 	Link level to style:	Vincular nivel con estilo:
 	List Definition	Definición de lista
+	Mark grammar errors as you type	Marcar errores gramaticales mientras escribes
+	Measurement units:	Unidades de medida:
+	Millimeters	Milímetros
+	New comments and tracked changes are recorded under this name and these initials.	Los comentarios y cambios con seguimiento nuevos se registran con este nombre y estas iniciales.
+	New word	Palabra nueva
+	No words yet. Add to Dictionary on a misspelled word puts it here.	Aún no hay palabras. Añadir al diccionario sobre una palabra mal escrita la pone aquí.
+	Mirror indents	Sangrías simétricas
 	Nothing	Nada
 	Number alignment:	Alineación del número:
 	Number format	Formato de número
 	Number style for this level:	Estilo de número para este nivel:
 	Outside border	Borde exterior
+	Overtype	Sobrescribir
+	Overtype (typing replaces the characters after the caret)	Sobrescribir (lo que escribes reemplaza los caracteres tras el cursor)
+	Page display	Visualización de página
+	Paragraph marks	Marcas de párrafo
+	Personalize	Personalizar
+	Picas	Picas
+	Points	Puntos
+	Print the page color	Imprimir el color de página
+	Printing	Impresión
+	Proofing language	Idioma de revisión
+	Recent documents to show:	Documentos recientes que mostrar:
+	Remove	Quitar
+	Outside:	Exterior:
 	Restart list after:	Reiniciar lista después de:
 	Right border	Borde derecho
 	Save the document to turn on AutoSave	Guarda el documento para activar el autoguardado
 	Save the document to turn on AutoSave (a file you have only opened isn't rewritten until you save it)	Guarda el documento para activar el autoguardado (un archivo que solo has abierto no se reescribe hasta que lo guardes)
+	Save documents	Guardar documentos
 	AutoText	Texto automático
 	Automatic	Automático
 	Automatic ({language})	Automático ({language})
@@ -126,6 +166,11 @@
 	Border Painter	Pincel de bordes
 	Border\nPainter	Pincel de\nbordes
 	Borders	Bordes
+	Show the mini toolbar when text is selected	Mostrar la minibarra de herramientas al seleccionar texto
+	Spaces	Espacios
+	Spelling	Ortografía
+	Spelling and grammar are checked in English (United States).	La ortografía y la gramática se revisan en inglés (Estados Unidos).
+	Tab characters	Caracteres de tabulación
 	Tab stop position:	Posición de la tabulación:
 	Default tab stops:	Tabulaciones predeterminadas:
 	Tab stops to be cleared:	Tabulaciones que se borrarán:
@@ -136,6 +181,10 @@
 	Set	Fijar
 	Page Border	Borde de página
 	Apply to:	Aplicar a:
+	These marks show even when Show/Hide ¶ is off.	Estas marcas se muestran aunque Mostrar u ocultar ¶ esté desactivado.
+	Typing replaces selected text	Lo que escribes reemplaza el texto seleccionado
+	Update fields before printing	Actualizar campos antes de imprimir
+	Use the Insert key to switch overtype on and off	Usar la tecla Insert para activar y desactivar la sobrescritura
 	Whole document	Todo el documento
 	This section	Esta sección
 	Fill	Relleno de color
@@ -329,6 +378,7 @@
 	Export a copy to share (PDF, Word document)	Exporta una copia para compartir (PDF, documento de Word)
 	Exported {path}	Exportado: {path}
 	Extend Selection	Ampliar selección
+	Extend Selection by Units	Ampliar selección por unidades
 	Field	Campo
 	File	Archivo
 	Find	Buscar
@@ -654,7 +704,6 @@
 	Reject All Changes	Rechazar todos los cambios
 	Reject Change	Rechazar cambio
 	Relaxed	Relajado
-	Remove	Quitar
 	Remove Background	Quitar fondo
 	Remove Footer	Quitar pie de página
 	Remove Header	Quitar encabezado
@@ -759,6 +808,9 @@
 	Show only comments and formatting in balloons	Mostrar solo comentarios y formato en globos
 	Show revisions in balloons	Mostrar revisiones en globos
 	Show rulers	Mostrar reglas
+	Animation	Animación
+	Animate the caret (it glides and fades)	Animar el cursor (se desliza y se desvanece)
+	On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off.	Activado: el cursor se desliza hasta su nueva posición al escribir o usar las flechas, y su parpadeo se desvanece. Desactivado: salta y parpadea de golpe.
 	Show the community button in the title bar	Mostrar el botón de comunidad en la barra de título
 	Show/Hide ¶	Mostrar u ocultar ¶
 	Show\nComments	Mostrar\ncomentarios
@@ -903,12 +955,12 @@
 	Wide	Ancho
 	Widow/Orphan Control	Control de líneas viudas y huérfanas
 	Widow/Orphan control	Control de líneas viudas y huérfanas
-	Wildcards (regex)	Comodines (expresión regular)
 	Window	Ventana
 	Word Count	Recuento de palabras
 	Word Left	Palabra a la izquierda
 	Word Right	Palabra a la derecha
 	Word document (*.docx)	Documento de Word (*.docx)
+	Word XML Document (*.xml)	Documento XML de Word (*.xml)
 	WordArt	WordArt
 	WordCraft	WordCraft
 	Words	Palabras
@@ -1364,8 +1416,86 @@
 	Selected Fields	Campos seleccionados
 	Edit Field…	Editar campo…
 	Formatted	Con formato
+	Deleted	Eliminado
 	Interface size:	Tamaño de la interfaz:
 	Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate.	Agranda o reduce la cinta, los menús y los cuadros de diálogo, además del escalado de pantalla del sistema. El zoom del documento es aparte.
+	Resize Table by Dragging	Cambiar tamaño de tabla arrastrando
+	Print Markup	Imprimir marcas
+	Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text.	Comentarios junto a cada página y cambios marcados en PDF, impresiones e imágenes; una lista de comentarios al final de páginas web, Markdown y texto.
+
+# Compare / Combine, AutoCorrect Options and Restrict Editing (#412)
+	1. Formatting restrictions	1. Restricciones de formato
+	2. Editing restrictions	2. Restricciones de edición
+	3. Start enforcement	3. Aplicar la protección
+	<< Less	<< Menos
+	Another file	Otro archivo
+	Apply as you type	Aplicar mientras escribe
+	AutoCorrect	Autocorrección
+	AutoFormat As You Type	Autoformato al escribir
+	Automatic bulleted lists	Listas con viñetas automáticas
+	Automatic numbered lists	Listas numeradas automáticas
+	Border lines	Líneas de borde
+	Capitalize first letter of sentences	Poner en mayúscula la primera letra de las oraciones
+	Capitalize first letter of table cells	Poner en mayúscula la primera letra de las celdas
+	Capitalize names of days	Poner en mayúscula los nombres de los días
+	Case changes	Cambios de mayúsculas
+	Character level	Nivel de carácter
+	Checked styles are allowed:	Los estilos marcados están permitidos:
+	Combine Documents	Combinar documentos
+	Compare Documents	Comparar documentos
+	Compared: {changes} changes	Comparado: {changes} cambios
+	Comparing with another file needs the desktop app.	Para comparar con otro archivo se necesita la aplicación de escritorio.
+	Comparison settings	Configuración de comparación
+	Don't capitalize after:	No poner mayúscula después de:
+	Editing in this document is restricted.	La edición de este documento está restringida.
+	Every change is recorded as a tracked change.	Cada cambio se registra como cambio con seguimiento.
+	Everyone	Todos
+	Exceptions (optional)	Excepciones (opcional)
+	Exceptions…	Excepciones…
+	Fields	Campos
+	Filling in forms	Rellenar formularios
+	Find Next Editable Region	Buscar la siguiente región editable
+	Footnotes and endnotes	Notas al pie y notas al final
+	Formatting, case changes, white space and tables are compared; the other settings are kept for later.	Se comparan el formato, las mayúsculas, los espacios en blanco y las tablas; los demás ajustes se guardan para más adelante.
+	Fractions (1/2) as fraction characters (½)	Fracciones (1/2) como caracteres de fracción (½)
+	Headers and footers	Encabezados y pies de página
+	Hyphens (--) as dashes (—)	Guiones (--) como rayas (—)
+	In equations, typing a name after a backslash replaces it with its symbol.	En las ecuaciones, escribir un nombre después de una barra invertida lo sustituye por su símbolo.
+	Internet addresses as links	Direcciones de Internet como vínculos
+	Label changes with:	Etiquetar cambios con:
+	Limit formatting to a selection of styles	Limitar el formato a una selección de estilos
+	Math AutoCorrect	Autocorrección matemática
+	More >>	Más >>
+	Moves	Movimientos
+	New document	Documento nuevo
+	No changes (read only)	Sin cambios (solo lectura)
+	Only allow this kind of editing:	Permitir solo este tipo de edición:
+	Only comments can be added, except in regions marked editable.	Solo se pueden añadir comentarios, salvo en las regiones marcadas como editables.
+	Only form fields can be filled in.	Solo se pueden rellenar los campos de formulario.
+	Only the allowed styles can be applied.	Solo se pueden aplicar los estilos permitidos.
+	Ordinals (1st) as superscript	Ordinales (1st) como superíndice
+	Original document	Documento original
+	This password type isn't supported.	Este tipo de contraseña no es compatible.
+	Replace as you type	Reemplazar mientras escribe
+	Replace text as you type	Reemplazar texto mientras escribe
+	Replace:	Reemplazar:
+	Revised document	Documento revisado
+	Select text, then tick who can still edit it.	Selecciona texto y marca quién puede seguir editándolo.
+	Settings…	Configuración…
+	Show changes at:	Mostrar cambios a nivel de:
+	Show changes in:	Mostrar cambios en:
+	Smart quotes instead of straight quotes	Comillas tipográficas en lugar de rectas
+	Start Enforcing Protection	Aplicar la protección
+	Stop Protection	Detener protección
+	Text boxes	Cuadros de texto
+	The document is read only, except for regions marked editable.	El documento es de solo lectura, salvo las regiones marcadas como editables.
+	The password is optional; without it anyone can stop the protection.	La contraseña es opcional; sin ella, cualquiera puede detener la protección.
+	This document	Este documento
+	Tracked changes	Cambios con seguimiento
+	Type the password to stop the protection.	Escribe la contraseña para detener la protección.
+	White space	Espacios en blanco
+	With:	Con:
+	Word level	Nivel de palabra
 	In Line with Text	En línea con el texto
 	Square	Cuadrado
 	Through	Transparente
@@ -1412,6 +1542,36 @@
 	New Group	Nuevo grupo
 	Rename…	Cambiar nombre…
 	Ribbon and Quick Access Toolbar:	Cinta de opciones y barra de acceso rápido:
+	Add Font…	Agregar fuente…
+	Added Fonts	Fuentes agregadas
+	Remove Added Font	Quitar fuente agregada
+	Recent Colors	Colores recientes
+	More Colors…	Más colores…
+	Standard	Estándar
+	Current	Actual
+	Colors:	Colores:
+	Color model:	Modelo de color:
+	Red:	Rojo:
+	Green:	Verde:
+	Blue:	Azul:
+	Hue:	Matiz:
+	Sat:	Sat.:
+	Lum:	Lum.:
+	Hex:	Hex.:
+	Accessibility Pane	Panel de accesibilidad
+	Alt Text Pane	Panel de texto alternativo
+	Alt\nText	Texto\nalternativo
+	View Alt Text…	Ver texto alternativo…
+	Mark as decorative	Marcar como decorativo
+	Title:	Título:
+	Errors ({n})	Errores ({n})
+	Warnings ({n})	Advertencias ({n})
+	Tips ({n})	Sugerencias ({n})
+	No accessibility issues found.	No se encontraron problemas de accesibilidad.
+	Describe what this object shows, for people who can't see it.	Describa lo que muestra este objeto para quienes no pueden verlo.
+	Decorative objects only add visual interest: screen readers skip them.	Los objetos decorativos solo aportan interés visual: los lectores de pantalla los omiten.
+	Describe what this table shows, for people who can't see it.	Describa lo que muestra esta tabla para quienes no pueden verla.
+	Select a picture, shape, chart or table to describe it.	Seleccione una imagen, forma, gráfico o tabla para describirlo.
 	Document Grid	Cuadrícula del documento
 	No grid	Sin cuadrícula
 	Lines only	Solo líneas
@@ -1421,6 +1581,39 @@
 	Lines per page:	Líneas por página:
 	Moved from	Movido desde
 	Moved to	Movido a
+	Developer	Programador
+	Controls	Controles
+	Rich Text Content Control	Control de contenido de texto enriquecido
+	Plain Text Content Control	Control de contenido de texto sin formato
+	Picture Content Control	Control de contenido de imagen
+	Building Block Gallery Content Control	Control de contenido de galería de bloques de creación
+	Check Box Content Control	Control de contenido de casilla
+	Combo Box Content Control	Control de contenido de cuadro combinado
+	Drop-Down List Content Control	Control de contenido de lista desplegable
+	Date Picker Content Control	Control de contenido de selector de fecha
+	Repeating Section Content Control	Control de contenido de sección repetida
+	Design Mode	Modo Diseño
+	Content Control at Selection	Control de contenido en la selección
+	Toggle Check Box	Alternar casilla
+	Choose List Item	Elegir elemento de la lista
+	Set Date	Establecer fecha
+	Remove Content Control	Quitar control de contenido
+	Content Control Properties	Propiedades del control de contenido
+	Title	Título
+	Tag	Etiqueta
+	Placeholder text	Texto del marcador de posición
+	Can't be deleted	No se puede eliminar
+	Contents can't be edited	El contenido no se puede editar
+	Remove the control once edited	Quitar el control al editarlo
+	Allow line breaks	Permitir saltos de línea
+	Date format	Formato de fecha
+	Checked symbol	Símbolo marcado
+	Unchecked symbol	Símbolo sin marcar
+	List entries	Entradas de la lista
+	Display text	Texto mostrado
+	Value	Valor
+	Today	Hoy
+	Put the caret in a content control first.	Coloque primero el cursor en un control de contenido.
 	Right-to-Left Table	Tabla de derecha a izquierda
 	Right-to-Left Section	Sección de derecha a izquierda
 	Table direction:	Dirección de la tabla:
@@ -1448,6 +1641,50 @@
 	Enlarge symbol	Agrandar símbolo
 	Enclosure	Contorno
 	Circle	Círculo
+	Templates	Plantillas
+	Templates and Add-ins	Plantillas y complementos
+	Attach Template	Adjuntar plantilla
+	Detach Template	Quitar plantilla
+	Automatically Update Document Styles	Actualizar automáticamente los estilos del documento
+	Update Styles from Template	Actualizar estilos desde la plantilla
+	Organizer	Organizador
+	Copy Styles	Copiar estilos
+	Rename Style	Cambiar nombre del estilo
+	Document template:	Plantilla del documento:
+	Attach…	Adjuntar…
+	Automatically update document styles	Actualizar automáticamente los estilos del documento
+	Organizer…	Organizador…
+	Change Chart Type	Cambiar tipo de gráfico
+	Chart Design	Diseño de gráfico
+	Type	Tipo
+	Edit Data	Editar datos
+	Chart Title	Título del gráfico
+	Chart Layouts	Diseños de gráfico
+	Add Chart Element	Agregar elemento de gráfico
+	Legend	Leyenda
+	Data Labels	Etiquetas de datos
+	Above Chart	Encima del gráfico
+	Insert Chart	Insertar gráfico
+	Clustered Column	Columnas agrupadas
+	Stacked Column	Columnas apiladas
+	Clustered Bar	Barras agrupadas
+	Stacked Bar	Barras apiladas
+	Area	Área
+	Pie	Circular
+	Doughnut	Anillo
+	Scatter	Dispersión
+	“{text}” ({row}, {series}) isn't a number.	«{text}» ({row}, {series}) no es un número.
+	Category {n}	Categoría {n}
+	Series {n}	Serie {n}
+	Type the categories down the side and a column of values per series.	Escribe las categorías en el lateral y una columna de valores por serie.
+	Categories	Categorías
+	Series name	Nombre de la serie
+	Remove series	Quitar serie
+	Remove row	Quitar fila
+	Add Row	Agregar fila
+	Add Series	Agregar serie
+	Edit\nData	Editar\ndatos
+	Change\nChart Type	Cambiar tipo\nde gráfico
 	Align Text	Alinear texto
 	Create Link	Crear vínculo
 	Break Link	Romper vínculo
@@ -1472,3 +1709,346 @@
 	English (United Kingdom)	Inglés (Reino Unido)
 	Polish	Polaco
 	Do Not Check Spelling or Grammar	No revisar la ortografía ni la gramática
+
+# Built-in file browser when the system file dialog is unavailable (#576)
+	Documents	Documentos
+	Word document	Documento de Word
+	All files	Todos los archivos
+	Recipient lists	Listas de destinatarios
+	The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity.	El cuadro de diálogo de archivos del sistema no está disponible, así que WordCraft muestra el suyo. Para usar el del sistema, instala un portal selector de archivos (como xdg-desktop-portal-gtk) o zenity.
+	Up one level	Subir un nivel
+	Home folder	Carpeta personal
+	{name} wasn't found.	No se encontró {name}.
+	{name} already exists. Choose Save again to replace it.	{name} ya existe. Elige Guardar otra vez para reemplazarlo.
+	This folder can't be read: {error}	No se puede leer esta carpeta: {error}
+	Showing the first {count} items.	Se muestran los primeros {count} elementos.
+	File name:	Nombre de archivo:
+	Browse in WordCraft…	Examinar en WordCraft…
+	Open a file with WordCraft's own browser when the system file dialog doesn't appear.	Abre un archivo con el explorador propio de WordCraft cuando no aparece el cuadro de diálogo de archivos del sistema.
+	Hide White Space	Ocultar espacio en blanco
+	All pages	Todas las páginas
+	Current page	Página actual
+	Selected pages	Páginas seleccionadas
+	Custom range	Intervalo personalizado
+	All pages in the range	Todas las páginas del intervalo
+	Odd pages only	Solo páginas impares
+	Even pages only	Solo páginas pares
+	Copies	Copias
+	Collate copies	Intercalar copias
+	Pages like 1-3, 5	Páginas como 1-3, 5
+	{count} of {total} pages will print	Se imprimirán {count} de {total} páginas
+	Save these pages as PDF…	Guardar estas páginas como PDF…
+	The printer, two-sided printing and pages per sheet are chosen in that dialog.	La impresora, la impresión a doble cara y las páginas por hoja se eligen en ese cuadro de diálogo.
+	Previous Page	Página anterior
+	Print to PDF	Imprimir en PDF
+	Add Shape	Agregar forma
+	Change Colors	Cambiar colores
+	Change Layout	Cambiar diseño
+	Create Graphic	Crear gráfico
+	Edit Items	Editar elementos
+	Layouts	Diseños
+	Reset Graphic	Restablecer gráfico
+	SmartArt Design	Diseño de SmartArt
+	SmartArt Styles	Estilos de SmartArt
+	Text Pane	Panel de texto
+	List	Lista
+	Process	Proceso
+	Cycle	Ciclo
+	Hierarchy	Jerarquía
+	Relationship	Relación
+	Pyramid	Pirámide
+	Basic List	Lista básica
+	Basic Process	Proceso básico
+	Basic Cycle	Ciclo básico
+	Basic Pyramid	Pirámide básica
+	Basic Radial	Radial básico
+	Basic Matrix	Matriz básica
+	Basic Venn	Venn básico
+	Shows items of equal weight as blocks in rows.	Muestra elementos de igual peso como bloques en filas.
+	Shows steps in order, left to right, with arrows between them.	Muestra pasos en orden, de izquierda a derecha, con flechas entre ellos.
+	Shows steps that repeat, around a circle.	Muestra pasos que se repiten, alrededor de un círculo.
+	Shows a tree: each item below the item it belongs to.	Muestra un árbol: cada elemento debajo del elemento al que pertenece.
+	Shows parts that build on each other, largest at the bottom.	Muestra partes que se apoyan unas en otras, la mayor abajo.
+	Shows items around a central idea: the first item is the centre.	Muestra elementos alrededor de una idea central: el primer elemento es el centro.
+	Shows parts of a whole as quadrants.	Muestra las partes de un todo como cuadrantes.
+	Shows overlapping ideas as overlapping circles.	Muestra ideas que se superponen como círculos superpuestos.
+	Accent {n}	Énfasis {n}
+	Colorful	Multicolor
+	Insert SmartArt	Insertar SmartArt
+	One line per item. Enter adds an item.	Una línea por elemento. Intro agrega un elemento.
+	Add\nShape	Agregar\nforma
+	Change\nColors	Cambiar\ncolores
+	Reset\nGraphic	Restablecer\ngráfico
+	Promote to Heading 1	Promover a Título 1
+	Demote to Body Text	Degradar a texto independiente
+	Move Up	Subir
+	Move Down	Bajar
+	Collapse	Contraer
+	Expand or Collapse Heading	Expandir o contraer título
+	Select Heading and Content	Seleccionar título y contenido
+	Show Level	Mostrar nivel
+	Show Level 1	Mostrar nivel 1
+	Show Level 2	Mostrar nivel 2
+	Show Level 3	Mostrar nivel 3
+	Show Level 4	Mostrar nivel 4
+	Show Level 5	Mostrar nivel 5
+	Show Level 6	Mostrar nivel 6
+	Show Level 7	Mostrar nivel 7
+	Show Level 8	Mostrar nivel 8
+	Show Level 9	Mostrar nivel 9
+	Show All Levels	Mostrar todos los niveles
+	All Levels	Todos los niveles
+	Show First Line Only	Mostrar solo la primera línea
+	Show Text Formatting	Mostrar formato de texto
+	Close Outline View	Cerrar vista Esquema
+	Outline State	Estado del esquema
+	Outlining	Esquema
+	Outline Tools	Herramientas de esquema
+	Close Outline\nView	Cerrar vista\nEsquema
+	A, B, C, …	A, B, C, …
+	Above the item	Encima del elemento
+	Accessed on	Consultado el
+	Add New Source…	Agregar nueva fuente…
+	Add the chapter number	Agregar el número de capítulo
+	Atmosphere	Atmósfera
+	Below the item	Debajo del elemento
+	Book	Libro
+	Book title	Título del libro
+	Caption	Leyenda
+	Caption Numbering	Numeración de leyendas
+	Caption text	Texto de la leyenda
+	Caption:	Leyenda:
+	Chapter in a book	Capítulo de libro
+	Chapters begin at:	Los capítulos empiezan en:
+	Collect entries from:	Recoger entradas de:
+	Columns:	Columnas:
+	Conference	Conferencia
+	Conference paper	Ponencia de conferencia
+	Container Title	Título del contenedor
+	Create Source	Crear fuente
+	Cross-reference:	Referencia cruzada:
+	Custom Table of Contents…	Tabla de contenido personalizada…
+	DOI	DOI
+	Day	Día
+	Delete Label	Eliminar rótulo
+	Edit Source	Editar fuente
+	Edition	Edición
+	Edit…	Editar…
+	Entry marked.	Entrada marcada.
+	Example: {sample}	Ejemplo: {sample}
+	Figure	Figura
+	Film	Película
+	Heading styles (levels 1–{n})	Estilos de título (niveles 1–{n})
+	Heading {n}	Título {n}
+	I, II, III, …	I, II, III, …
+	Include page numbers	Incluir números de página
+	Indented	Con sangría
+	Institution	Institución
+	Ionosphere	Ionosfera
+	Issue	Número
+	Journal	Revista
+	Label:	Rótulo:
+	Last, First; Last, First	Apellido, Nombre; Apellido, Nombre
+	Leave the label out of the caption	Omitir el rótulo en la leyenda
+	Letter headings	Encabezados de letra
+	Levels:	Niveles:
+	Link entries to their headings	Vincular las entradas a sus títulos
+	Made from the author and year when empty	Si está vacío, se forma con autor y año
+	Magazine or newspaper article	Artículo de revista o periódico
+	Main entry:	Entrada principal:
+	Mark	Marcar
+	Mark All	Marcar todas
+	Mark Entry…	Marcar entrada…
+	Mark Index Entry	Marcar entrada de índice
+	Mesosphere	Mesosfera
+	Month	Mes
+	New Label	Nuevo rótulo
+	New Label…	Nuevo rótulo…
+	New…	Nueva…
+	No sources yet.	Aún no hay fuentes.
+	Numbering…	Numeración…
+	Options…	Opciones…
+	Other	Otro
+	Other styles and their TOC level:	Otros estilos y su nivel en la tabla:
+	Outline levels	Niveles de esquema
+	Page number style	Estilo del número de página
+	Page numbers at the right margin	Números de página en el margen derecho
+	Page title	Título de la página
+	Pages of bookmark:	Páginas del marcador:
+	Periodical	Publicación periódica
+	Position:	Posición:
+	Publisher	Editorial
+	Run-in	Continuo
+	See	Véase
+	Separator:	Separador:
+	Show every bibliography field	Mostrar todos los campos bibliográficos
+	Site name	Nombre del sitio
+	Source Manager	Administrador de fuentes
+	Source type:	Tipo de fuente:
+	Sources in this document:	Fuentes de este documento:
+	Styles:	Estilos:
+	Subentry:	Subentrada:
+	TC entry fields	Campos de entrada TC
+	Tab leader:	Carácter de relleno:
+	Table of Contents Options	Opciones de tabla de contenido
+	Table of Contents Styles	Estilos de tabla de contenido
+	This page	Esta página
+	Type:	Tipo:
+	URL	URL
+	Volume	Volumen
+	Website	Sitio web
+	Year	Año
+	a, b, c, …	a, b, c, …
+	i, ii, iii, …	i, ii, iii, …
+	{n} entries marked.	Entradas marcadas: {n}.
+	Lasso Select	Selección con lazo
+	Move Selected Ink	Mover la tinta seleccionada
+	Delete Selected Ink	Eliminar la tinta seleccionada
+	Recolor Selected Ink	Cambiar el color de la tinta seleccionada
+	Add Pen	Agregar pluma
+	Remove Pen	Quitar pluma
+	Ink to Shape	Tinta a forma
+	Convert to Shapes	Convertir en formas
+	Ink Replay	Reproducir tinta
+	Add\nPen	Agregar\npluma
+	Rewind	Rebobinar
+	Forward	Avanzar
+	Stroke {n} of {total}	Trazo {n} de {total}
+	Use wildcards	Usar caracteres comodín
+	Special	Especial
+	Match prefix	Coincidir prefijo
+	Match suffix	Coincidir sufijo
+	Ignore punctuation characters	Omitir signos de puntuación
+	Ignore white-space characters	Omitir espacios en blanco
+	Regular expressions	Expresiones regulares
+	Search Options	Opciones de búsqueda
+	Tab Character	Carácter de tabulación
+	Any Character	Cualquier carácter
+	Any Digit	Cualquier dígito
+	Any Letter	Cualquier letra
+	Caret Character	Acento circunflejo
+	Section Character	Símbolo de sección
+	Paragraph Character	Símbolo de párrafo
+	Graphic	Gráfico
+	Manual Line Break	Salto de línea manual
+	Manual Page Break	Salto de página manual
+	Section Break	Salto de sección
+	White Space	Espacio en blanco
+	Clipboard Contents	Contenido del portapapeles
+	Find What Text	Texto buscado
+	Find What Expression	Expresión buscada
+	Character in Range	Carácter del intervalo
+	Beginning of Word	Principio de palabra
+	End of Word	Final de palabra
+	Expression	Expresión
+	Not	No
+	Num Occurrences	Número de repeticiones
+	Previous 1 or More	Anterior 1 o más veces
+	0 or More Characters	0 o más caracteres
+	Move with Text	Mover con el texto
+	Fix Position on Page	Fijar posición en la página
+
+# WordArt and connectors (#416).
+	WordArt Styles	Estilos de WordArt
+	Text Fill	Relleno de texto
+	Text Outline	Contorno de texto
+	Transform	Transformar
+	No Fill	Sin relleno
+	No Outline	Sin contorno
+	Reflection	Reflejo
+	No Reflection	Sin reflejo
+	No Transform	Sin transformación
+	Connect Shapes	Conectar formas
+	Straight Connector	Conector recto
+	Straight Arrow Connector	Conector recto de flecha
+	Elbow Connector	Conector angular
+	Elbow Arrow Connector	Conector angular de flecha
+	Curved Connector	Conector curvo
+	Curved Arrow Connector	Conector curvo de flecha
+	Arch Up	Arco hacia arriba
+	Arch Down	Arco hacia abajo
+	Slant Up	Inclinación hacia arriba
+	Slant Down	Inclinación hacia abajo
+	Inflate	Inflar
+	Deflate	Desinflar
+	Chevron Up	Chevrón hacia arriba
+	Chevron Down	Chevrón hacia abajo
+	Triangle Up	Triángulo hacia arriba
+	Triangle Down	Triángulo hacia abajo
+	Solid Accent	Color de énfasis sólido
+	Light with Outline	Claro con contorno
+	Hollow	Hueco
+	Accent Gradient	Degradado de énfasis
+	Dark with Shadow	Oscuro con sombra
+	Soft Glow	Resplandor suave
+	Accent with Reflection	Énfasis con reflejo
+	Warm Gradient with Outline	Degradado cálido con contorno
+	Add line numbering	Agregar numeración de líneas
+	Add to Document	Agregar al documento
+	Address labels	Etiquetas de dirección
+	Arabic	Árabe
+	Auto	Auto
+	Automatically hyphenate document	Separar palabras automáticamente en el documento
+	Chinese (Simplified)	Chino (simplificado)
+	Chinese (Traditional)	Chino (tradicional)
+	Column:	Columna:
+	Count by:	Intervalo:
+	Czech	Checo
+	Danish	Danés
+	Delivery address:	Dirección del destinatario:
+	Detect language automatically	Detectar idioma automáticamente
+	Do not check spelling or grammar	No revisar la ortografía ni la gramática
+	Dutch	Neerlandés
+	Envelope size:	Tamaño del sobre:
+	Estonian	Estonio
+	Finnish	Finés
+	French (France)	Francés (Francia)
+	From text:	Desde el texto:
+	Full page of the same label	Página completa de la misma etiqueta
+	German (Germany)	Alemán (Alemania)
+	Greek	Griego
+	Hebrew	Hebreo
+	Hyphenate at:	Separar en:
+	Hyphenate words in CAPS	Separar palabras en MAYÚSCULAS
+	Hyphenation Options…	Opciones de separación de palabras…
+	Hyphenation zone:	Zona de separación:
+	Italian	Italiano
+	Japanese	Japonés
+	Korean	Coreano
+	Limit consecutive hyphens to:	Limitar guiones consecutivos a:
+	Line Numbering Options…	Opciones de numeración de líneas…
+	Manual Hyphenation	Separación manual de palabras
+	Manual hyphenation is complete.	La separación manual de palabras ha terminado.
+	Manual…	Manual…
+	Mark selected text as:	Marcar el texto seleccionado como:
+	New Document	Documento nuevo
+	No limit	Sin límite
+	Norwegian (Bokmål)	Noruego (bokmål)
+	Numbering:	Numeración:
+	Omit	Omitir
+	One label per recipient	Una etiqueta por destinatario
+	Portuguese (Brazil)	Portugués (Brasil)
+	Portuguese (Portugal)	Portugués (Portugal)
+	Return address labels	Etiquetas de remitente
+	Return address:	Dirección del remitente:
+	Row:	Fila:
+	Russian	Ruso
+	Serbian (Cyrillic)	Serbio (cirílico)
+	Serbian (Latin)	Serbio (latino)
+	Set As Default	Establecer como predeterminado
+	Shipping labels	Etiquetas de envío
+	Single label	Una sola etiqueta
+	Spanish (Mexico)	Español (México)
+	Spanish (Spain)	Español (España)
+	Swedish	Sueco
+	Turkish	Turco
+	Ukrainian	Ucraniano
+	{language} is now the document's default language.	{language} es ahora el idioma predeterminado del documento.
+	Visual effects	Efectos visuales
+	Animation effects:	Efectos de animación:
+	On	Activado
+	Off	Desactivado
+	Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.	Desplazamiento y zoom suaves, y menús y botones que aparecen gradualmente. Con «Desactivado», cada cambio se muestra al instante.
+	Your system has animation effects turned on.	Tu sistema tiene activados los efectos de animación.
+	Your system has animation effects turned off.	Tu sistema tiene desactivados los efectos de animación.
+	Your system doesn't report an animation setting, so animation effects stay on.	Tu sistema no indica ningún ajuste de animación, así que los efectos de animación siguen activados.
diff --git a/crates/ui-egui/src/i18n/et.tsv b/crates/ui-egui/src/i18n/et.tsv
index 39e7cc4af7..1ff4ce7da8 100644
--- a/crates/ui-egui/src/i18n/et.tsv
+++ b/crates/ui-egui/src/i18n/et.tsv
@@ -49,6 +49,8 @@
 	Arrange\nAll	Paiguta\nkõik
 	Arrow	Nool
 	Artistic Effects	Kunstilised efektid
+	As you type	Kirjutamise ajal
+	Asian text font:	Aasia teksti font:
 	Author	Autor
 	AutoCorrect Options	Automaatparanduse valikud
 	AutoFit	Automaatne sobitus
@@ -56,6 +58,7 @@
 	AutoFit Window	Sobita aknaga
 	AutoSave	Automaatsalvestus
 	AutoSave saves every change to the file (needs a saved document)	Automaatsalvestus salvestab iga muudatuse faili (dokument peab olema salvestatud)
+	AutoSave writes your changes to the file a moment after you stop typing.	Automaatsalvestus kirjutab muudatused faili veidi pärast seda, kui lõpetad kirjutamise.
 	AutoText	Automaattekst
 	Automatic	Automaatne
 	Automatic ({language})	Automaatne ({language})
@@ -96,6 +99,7 @@
 	Cell Size	Lahtri suurus
 	Cell\nMargins	Lahtri\nveerised
 	Center	Keskele
+	Centimeters	Sentimeetrid
 	Change	Muuda
 	Change Case	Muuda tähesuurust
 	Change List Level	Muuda loendi taset
@@ -114,6 +118,7 @@
 	Check Compatibility	Kontrolli ühilduvust
 	Check Spelling as You Type	Kontrolli õigekirja kirjutamise ajal
 	Check for Errors	Kontrolli vigu
+	Check spelling as you type	Kontrolli õigekirja kirjutamise ajal
 	Check\nAccessibility	Kontrolli\nligipääsetavust
 	Citation Style	Viitamisstiil
 	Citations & Bibliography	Viited ja allikaloend
@@ -124,6 +129,7 @@
 	Clear Character Style	Eemalda märgistiil
 	Clear Formatting Level	Eemalda vormindustase
 	Clear Paragraph Formatting	Eemalda lõiguvormindus
+	Click to switch back to inserting	Klõpsa, et naasta lisamisrežiimi
 	Clipboard	Lõikelaud
 	Close	Sulge
 	Close Header and Footer	Sulge päis ja jalus
@@ -164,6 +170,7 @@
 	Custom Margins…	Kohandatud veerised…
 	Custom Watermark	Kohandatud vesimärk
 	Custom Watermark…	Kohandatud vesimärk…
+	Custom dictionary	Kohandatud sõnastik
 	Customize Quick Access Toolbar	Kohanda kiirpääsuriba
 	Cut	Lõika
 	Dark Mode	Tume režiim
@@ -244,6 +251,7 @@
 	Export a copy to share (PDF, Word document)	Ekspordi koopia jagamiseks (PDF, Wordi dokument)
 	Exported {path}	Eksporditud: {path}
 	Extend Selection	Laienda valikut
+	Extend Selection by Units	Laienda valikut ühikute kaupa
 	Field	Väli
 	File	Fail
 	Find	Otsi
@@ -276,6 +284,8 @@
 	Format Painter	Vormingupintsel
 	Formatted Text	Vormindatud tekst
 	Formatting at Selection	Valiku vormindus
+	Formatting marks	Vormindusmärgid
+	Formatting exceptions	Vormindamise erandid
 	Formula	Valem
 	General	Üldine
 	Go To	Mine
@@ -301,6 +311,7 @@
 	Heart	Süda
 	Help	Abi
 	Hidden	Peidetud
+	Hidden text	Peidetud tekst
 	Highlight Merge Fields	Tõsta ühendamisväljad esile
 	Highlight\nMerge Fields	Tõsta ühendamis-\nväljad esile
 	Highlighter	Marker
@@ -310,10 +321,14 @@
 	Hyphenation	Poolitus
 	Icons	Ikoonid
 	Ignore All	Eira kõiki
+	Ignore web and file addresses	Eira veebi- ja failiaadresse
+	Ignore words in capitals	Eira suurtähtedega sõnu
+	Ignore words with numbers	Eira numbritega sõnu
 	Illustrations	Illustratsioonid
 	Immersive	Süvenemine
 	Immersive Reader	Süvaluger
 	Immersive\nReader	Süva-\nluger
+	Inches	Tollid
 	Increase Font Size	Suurenda fondi suurust
 	Increase Indent	Suurenda taanet
 	Indent	Taane
@@ -321,6 +336,7 @@
 	Indents	Taanded
 	Index	Register
 	Info	Teave
+	Initials:	Initsiaalid:
 	Ink to\nMath	Käsikiri\nvalemiks
 	Ink to\nShape	Käsikiri\nkujundiks
 	Ink\nReplay	Esita\nkäsikiri
@@ -347,8 +363,11 @@
 	Insert\nCitation	Lisa\nviide
 	Insert\nFootnote	Lisa\nallmärkus
 	Inside Borders	Siseäärised
+	Inside:	Sisemine:
 	Inspect Document	Kontrolli dokumenti
 	Inspect Styles at Selection	Kontrolli valiku stiile
+	Interface	Kasutajaliides
+	Interface language	Kasutajaliidese keel
 	Interface language:	Kasutajaliidese keel:
 	Italic	Kaldkiri
 	Join the ArtCraft community on Discord	Liitu ArtCrafti kogukonnaga Discordis
@@ -366,6 +385,7 @@
 	Lasso	Lasso
 	Last Column	Viimane veerg
 	Last commit	Viimane commit
+	Latin text font:	Ladina teksti font:
 	Layout	Paigutus
 	Layout Summary	Paigutuse kokkuvõte
 	Left	Vasak
@@ -390,6 +410,7 @@
 	Link to Previous	Seo eelmisega
 	Links	Lingid
 	Location: {path}	Asukoht: {path}
+	Mirror indents	Peegelda taanded
 	MIT OR Apache-2.0. Copyright (c) 2026 ArtCraft Team and the WordCraft contributors.	MIT OR Apache-2.0. Autoriõigus (c) 2026 ArtCrafti meeskond ja WordCrafti kaasautorid.
 	Macros	Makrod
 	Mailings	Postitused
@@ -398,16 +419,19 @@
 	Margins	Veerised
 	Mark Citation	Märgi õigusallikas
 	Mark Entry	Märgi registrikirje
+	Mark grammar errors as you type	Märgi grammatikavead kirjutamise ajal
 	Mark\nCitation	Märgi\nõigusallikas
 	Mark\nEntry	Märgi\nregistrikirje
 	Markdown (*.md)	Markdown (*.md)
 	Match Fields	Vastenda väljad
 	Match case	Erista suur- ja väiketähti
 	Matrix	Maatriks
+	Measurement units:	Mõõtühikud:
 	Merge	Ühenda
 	Merge Cells	Ühenda lahtrid
 	Merge Formatting	Ühenda vormindus
 	Merged PRs	Ühendatud PR-id
+	Millimeters	Millimeetrid
 	Mirrored	Peegeldatud
 	Moderate	Mõõdukas
 	Modify Style	Muuda stiili
@@ -426,7 +450,9 @@
 	New Paragraph	Uus lõik
 	New Style…	Uus stiil…
 	New Window	Uus aken
+	New comments and tracked changes are recorded under this name and these initials.	Uued kommentaarid ja jälitatud muudatused salvestatakse selle nime ja nende initsiaalidega.
 	New from Template	Uus mallist
+	New word	Uus sõna
 	New\nComment	Uus\nkommentaar
 	New\nWindow	Uus\naken
 	Next	Järgmine
@@ -443,6 +469,7 @@
 	No contributor data was built into this copy.	Selles versioonis pole kaasautorite andmeid.
 	No model credits were built into this copy.	Selles versioonis pole mudelite autoriteavet.
 	No templates match your search.	Otsingule vastavaid malle pole.
+	No words yet. Add to Dictionary on a misspelled word puts it here.	Sõnu veel pole. Valik „Lisa sõnastikku“ valesti kirjutatud sõnal lisab selle siia.
 	Nonbreaking Hyphen	Poolitamatu sidekriips
 	Nonbreaking Space	Poolitamatu tühik
 	None	Puudub
@@ -469,7 +496,10 @@
 	Outline	Liigendus
 	Outline Level	Liigendustase
 	Outside Borders	Välisäärised
+	Outside:	Välimine:
 	Oval	Ovaal
+	Overtype	Ülekirjutus
+	Overtype (typing replaces the characters after the caret)	Ülekirjutus (kirjutatu asendab kursori järel olevad märgid)
 	PDF document (*.pdf)	PDF-dokument (*.pdf)
 	Page	Leht
 	Page Background	Lehe taust
@@ -486,6 +516,7 @@
 	Page Width	Lehe laius
 	Page X of Y	Leht X / Y
 	Page break before	Lehepiir enne
+	Page display	Lehe kuvamine
 	Page image (*.png)	Lehe pilt (*.png)
 	Page width	Lehe laius
 	Page {page}	Leht {page}
@@ -500,6 +531,7 @@
 	Paragraph Settings	Lõigu sätted
 	Paragraph Spacing	Lõiguvahe
 	Paragraph Up	Lõigu võrra üles
+	Paragraph marks	Lõigumärgid
 	Paragraphs	Lõigud
 	Paste	Kleebi
 	Paste (⌘V)	Kleebi (⌘V)
@@ -511,11 +543,14 @@
 	Paste: Merge Formatting	Kleebi: ühenda vormindus
 	Pen	Pliiats
 	Pencil	Grafiitpliiats
+	Personalize	Isikupärastamine
+	Picas	Piikad
 	Picture Border	Pildi ääris
 	Picture Format	Pildi vorming
 	Picture Styles	Pildistiilid
 	Pictures	Pildid
 	Plain text (*.txt)	Lihttekst (*.txt)
+	Points	Punktid
 	Portrait	Püstpaigutus
 	Position	Asukoht
 	Preview Results	Tulemuste eelvaade
@@ -527,9 +562,12 @@
 	Previous Section	Eelmine jaotis
 	Print	Prindi
 	Print Layout	Prindipaigutus
+	Print the page color	Prindi lehe värv
 	Print\nLayout	Prindi-\npaigutus
+	Printing	Printimine
 	Proofing	Keelekontroll
 	Proofing Issues	Keelekontrolli probleemid
+	Proofing language	Keelekontrolli keel
 	Properties	Atribuudid
 	Protect	Kaitse
 	Protect Document	Kaitse dokumenti
@@ -544,6 +582,7 @@
 	Reads the clipboard's web content and keeps its formatting.	Loeb lõikelaualt veebisisu ja säilitab vorminduse.
 	Reading Highlight	Otsingutulemuste esiletõst
 	Recent	Hiljutised
+	Recent documents to show:	Kuvatavad hiljutised dokumendid:
 	Record Macro	Salvesta makro
 	Recover Unsaved Documents	Taasta salvestamata dokumendid
 	Rectangle	Ristkülik
@@ -554,6 +593,7 @@
 	Reject All Changes	Lükka kõik muudatused tagasi
 	Reject Change	Lükka muudatus tagasi
 	Relaxed	Hõre
+	Remove	Eemalda
 	Remove Background	Eemalda taust
 	Remove Footer	Eemalda jalus
 	Remove Header	Eemalda päis
@@ -604,6 +644,7 @@
 	Save As	Salvesta nimega
 	Save a copy in another format. Printing goes through a PDF you can print from any viewer.	Salvesta koopia teises vormingus. Printimiseks luuakse PDF, mille saad printida PDF-vaaturist.
 	Save as Template	Salvesta mallina
+	Save documents	Dokumentide salvestamine
 	Saved	Salvestatud
 	Search Commands	Otsi käske
 	Search commands and help	Otsi käske ja abi
@@ -651,7 +692,11 @@
 	Show Notes	Kuva märkused
 	Show all formatting marks	Kuva kõik vormindusmärgid
 	Show rulers	Kuva joonlauad
+	Animation	Animatsioon
+	Animate the caret (it glides and fades)	Animeeri tekstikursorit (libiseb ja hajub)
+	On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off.	Sees: tekstikursor libiseb tippimisel või nooleklahvide kasutamisel uude kohta ja selle vilkumine hajub sujuvalt. Väljas: kursor hüppab ja vilgub järsult.
 	Show the community button in the title bar	Kuva tiitliribal kogukonna nupp
+	Show the mini toolbar when text is selected	Kuva teksti valimisel minitööriistariba
 	Show/Hide ¶	Kuva/peida ¶
 	Show\nComments	Kuva\nkommentaarid
 	Shrink Font 1 Point	Vähenda fonti 1 punkti võrra
@@ -668,12 +713,15 @@
 	Sort	Sordi
 	Source code: github.com/storytold/wordcraft	Lähtekood: github.com/storytold/wordcraft
 	Space before/after:	Vahe enne/pärast:
+	Spaces	Tühikud
 	Spacing	Vahe
 	Spacing (pt):	Vahe (pt):
 	Speech	Kõne
+	Spelling	Õigekiri
 	Spelling & Grammar	Õigekiri ja grammatika
 	Spelling &\nGrammar	Õigekiri ja\ngrammatika
 	Spelling Suggestions	Õigekirjasoovitused
+	Spelling and grammar are checked in English (United States).	Õigekirja ja grammatikat kontrollitakse inglise keeles (Ameerika Ühendriigid).
 	Split	Tükelda
 	Split Cells	Tükelda lahtrid
 	Split Table	Tükelda tabel
@@ -702,6 +750,7 @@
 	Symbols	Sümbolid
 	Synonyms	Sünonüümid
 	Tab	Tabeldus
+	Tab characters	Tabeldusmärgid
 	Table	Tabel
 	Table Column Width	Tabeli veerulaius
 	Table Design	Tabeli kujundus
@@ -735,6 +784,7 @@
 	Theme List	Kujunduste loend
 	Themes	Kujundused
 	Thesaurus	Sünonüümisõnastik
+	These marks show even when Show/Hide ¶ is off.	Need märgid on nähtavad ka siis, kui Kuva/peida ¶ on välja lülitatud.
 	Thick	Paks
 	Three	Kolm
 	Tight	Tihe
@@ -751,6 +801,7 @@
 	Two	Kaks
 	Type Text	Sisesta tekst
 	Type a command, e.g. "insert table"	Sisesta käsk, nt "lisa tabel"
+	Typing replaces selected text	Kirjutatu asendab valitud teksti
 	UPPERCASE	SUURTÄHED
 	Underline	Allajoon
 	Underline Words Only	Jooni alla ainult sõnad
@@ -763,8 +814,10 @@
 	Update Style to Match Selection	Uuenda stiil valiku järgi
 	Update Table	Uuenda tabelit
 	Update Table of Figures	Uuenda illustratsioonide loendit
+	Update fields before printing	Värskenda välju enne printimist
 	Update to Match	Uuenda vastavaks
 	Update to Match Selection	Uuenda valiku järgi
+	Use the Insert key to switch overtype on and off	Kasuta Insert-klahvi ülekirjutuse sisse- ja väljalülitamiseks
 	User Name	Kasutajanimi
 	User name:	Kasutajanimi:
 	Version History	Versiooniajalugu
@@ -786,12 +839,12 @@
 	Wide	Lai
 	Widow/Orphan Control	Üksikridade vältimine
 	Widow/Orphan control	Üksikridade vältimine
-	Wildcards (regex)	Metamärgid (regulaaravaldis)
 	Window	Aken
 	Word Count	Sõnade arv
 	Word Left	Sõna vasakule
 	Word Right	Sõna paremale
 	Word document (*.docx)	Wordi dokument (*.docx)
+	Word XML Document (*.xml)	Wordi XML-dokument (*.xml)
 	WordArt	WordArt
 	WordCraft	WordCraft
 	Words	Sõnad
@@ -1349,8 +1402,86 @@
 	Choose the sheet that holds the recipients.	Valige leht, millel on adressaadid.
 	First row of data contains column headers	Andmete esimene rida sisaldab veerupäiseid
 	Formatted	Vormindatud
+	Deleted	Kustutatud
 	Interface size:	Kasutajaliidese suurus:
 	Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate.	Muudab menüülindi, menüüd ja dialoogid suuremaks või väiksemaks, lisaks süsteemi ekraani skaleerimisele. Dokumendi suum on eraldi.
+	Resize Table by Dragging	Tabeli suuruse muutmine lohistades
+	Print Markup	Prindi märgistus
+	Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text.	Kommentaarid iga lehe kõrval ja jälitatud muudatused PDF-ides, väljatrükkides ja piltides; kommentaaride loend veebilehtede, Markdowni ja teksti lõpus.
+
+# Compare / Combine, AutoCorrect Options and Restrict Editing (#412)
+	1. Formatting restrictions	1. Vormingupiirangud
+	2. Editing restrictions	2. Muutmispiirangud
+	3. Start enforcement	3. Kaitse jõustamine
+	<< Less	<< Vähem
+	Another file	Muu fail
+	Apply as you type	Rakenda tippimise ajal
+	AutoCorrect	Automaatparandus
+	AutoFormat As You Type	Automaatvorming tippimisel
+	Automatic bulleted lists	Automaatsed täpploendid
+	Automatic numbered lists	Automaatsed nummerloendid
+	Border lines	Äärisjooned
+	Capitalize first letter of sentences	Lausete esitäht suureks
+	Capitalize first letter of table cells	Tabelilahtrite esitäht suureks
+	Capitalize names of days	Nädalapäevade nimed suure algustähega
+	Case changes	Tähesuuruse muutused
+	Character level	Märgi tasandil
+	Checked styles are allowed:	Märgitud laadid on lubatud:
+	Combine Documents	Ühenda dokumendid
+	Compare Documents	Võrdle dokumente
+	Compared: {changes} changes	Võrreldud: {changes} muudatust
+	Comparing with another file needs the desktop app.	Teise failiga võrdlemiseks on vaja töölauarakendust.
+	Comparison settings	Võrdlemise sätted
+	Don't capitalize after:	Ära muuda suureks pärast:
+	Editing in this document is restricted.	Selle dokumendi muutmine on piiratud.
+	Every change is recorded as a tracked change.	Iga muudatus salvestatakse jälitatud muudatusena.
+	Everyone	Kõik
+	Exceptions (optional)	Erandid (valikuline)
+	Exceptions…	Erandid…
+	Fields	Väljad
+	Filling in forms	Vormide täitmine
+	Find Next Editable Region	Leia järgmine muudetav piirkond
+	Footnotes and endnotes	Allmärkused ja lõpumärkused
+	Formatting, case changes, white space and tables are compared; the other settings are kept for later.	Võrreldakse vormingut, tähesuurust, tühikuid ja tabeleid; ülejäänud sätted jäävad hilisemaks.
+	Fractions (1/2) as fraction characters (½)	Murrud (1/2) murrumärkidena (½)
+	Headers and footers	Päised ja jalused
+	Hyphens (--) as dashes (—)	Sidekriipsud (--) mõttekriipsudena (—)
+	In equations, typing a name after a backslash replaces it with its symbol.	Võrrandites asendatakse kaldkriipsu järel tipitud nimi selle sümboliga.
+	Internet addresses as links	Internetiaadressid linkidena
+	Label changes with:	Muudatuste silt:
+	Limit formatting to a selection of styles	Piira vorming valitud laadidega
+	Math AutoCorrect	Matemaatika automaatparandus
+	More >>	Rohkem >>
+	Moves	Teisaldused
+	New document	Uus dokument
+	No changes (read only)	Muudatusi pole (kirjutuskaitstud)
+	Only allow this kind of editing:	Luba ainult seda tüüpi muutmist:
+	Only comments can be added, except in regions marked editable.	Lisada saab ainult kommentaare, välja arvatud muudetavaks märgitud piirkondades.
+	Only form fields can be filled in.	Täita saab ainult vormivälju.
+	Only the allowed styles can be applied.	Rakendada saab ainult lubatud laade.
+	Ordinals (1st) as superscript	Järgarvud (1st) ülaindeksina
+	Original document	Algdokument
+	This password type isn't supported.	Seda paroolitüüpi ei toetata.
+	Replace as you type	Asenda tippimise ajal
+	Replace text as you type	Asenda tekst tippimise ajal
+	Replace:	Asenda:
+	Revised document	Muudetud dokument
+	Select text, then tick who can still edit it.	Vali tekst ja märgi, kes saab seda veel muuta.
+	Settings…	Sätted…
+	Show changes at:	Kuva muudatused tasandil:
+	Show changes in:	Kuva muudatused:
+	Smart quotes instead of straight quotes	Nutikad jutumärgid sirgete asemel
+	Start Enforcing Protection	Jõusta kaitse
+	Stop Protection	Lõpeta kaitse
+	Text boxes	Tekstiväljad
+	The document is read only, except for regions marked editable.	Dokument on kirjutuskaitstud, välja arvatud muudetavaks märgitud piirkonnad.
+	The password is optional; without it anyone can stop the protection.	Parool on valikuline; ilma selleta saab igaüks kaitse lõpetada.
+	This document	See dokument
+	Tracked changes	Jälitatud muudatused
+	Type the password to stop the protection.	Kaitse lõpetamiseks sisesta parool.
+	White space	Tühikud
+	With:	Millega:
+	Word level	Sõna tasandil
 	In Line with Text	Tekstiga reas
 	Square	Ruudukujuline
 	Through	Läbiv
@@ -1376,7 +1507,6 @@
 	Not used by any command	Ükski käsk ei kasuta seda
 	Now used by {command}	Praegu kasutab: {command}
 	Press a key combination	Vajuta klahvikombinatsiooni
-	Remove	Eemalda
 	Remove every custom shortcut and restore the built-in keys?	Kas eemaldada kõik kohandatud kiirklahvid ja taastada sisseehitatud klahvid?
 	Reset All…	Lähtesta kõik…
 	(Custom)	(Kohandatud)
@@ -1398,6 +1528,22 @@
 	Ribbon	Lint
 	Ribbon and Quick Access Toolbar:	Lint ja kiirpääsuriba:
 	Ribbon tabs	Lindi vahekaardid
+	Add Font…	Lisa font…
+	Added Fonts	Lisatud fondid
+	Remove Added Font	Eemalda lisatud font
+	Recent Colors	Viimati kasutatud värvid
+	More Colors…	Rohkem värve…
+	Standard	Standard
+	Current	Praegune
+	Colors:	Värvid:
+	Color model:	Värvimudel:
+	Red:	Punane:
+	Green:	Roheline:
+	Blue:	Sinine:
+	Hue:	Toon:
+	Sat:	Küllastus:
+	Lum:	Heledus:
+	Hex:	Hex:
 	Right-to-Left Table	Paremalt vasakule tabel
 	Right-to-Left Section	Paremalt vasakule jaotis
 	Table direction:	Tabeli suund:
@@ -1433,8 +1579,52 @@
 	Right (vertical)	Paremal (vertikaalne)
 	Ruby text:	Ruby-tekst:
 	Size (pt):	Suurus (pt):
+	Templates	Mallid
+	Templates and Add-ins	Mallid ja lisandmoodulid
+	Attach Template	Manusta mall
+	Detach Template	Eemalda mall
+	Automatically Update Document Styles	Uuenda dokumendi stiile automaatselt
+	Update Styles from Template	Uuenda stiile mallist
+	Organizer	Korraldaja
+	Copy Styles	Kopeeri stiilid
+	Rename Style	Nimeta stiil ümber
+	Document template:	Dokumendi mall:
+	Attach…	Manusta…
+	Automatically update document styles	Uuenda dokumendi stiile automaatselt
+	Organizer…	Korraldaja…
 	Moved from	Teisaldatud kohast
 	Moved to	Teisaldatud kohta
+	Change Chart Type	Muuda diagrammi tüüpi
+	Chart Design	Diagrammi kujundus
+	Type	Tüüp
+	Edit Data	Redigeeri andmeid
+	Chart Title	Diagrammi pealkiri
+	Chart Layouts	Diagrammi paigutused
+	Add Chart Element	Lisa diagrammi element
+	Legend	Legend
+	Data Labels	Andmesildid
+	Above Chart	Diagrammi kohal
+	Insert Chart	Lisa diagramm
+	Clustered Column	Rühmitatud tulbad
+	Stacked Column	Virnastatud tulbad
+	Clustered Bar	Rühmitatud ribad
+	Stacked Bar	Virnastatud ribad
+	Area	Pind
+	Pie	Sektor
+	Doughnut	Rõngas
+	Scatter	Hajuvus
+	“{text}” ({row}, {series}) isn't a number.	„{text}” ({row}, {series}) ei ole arv.
+	Category {n}	Kategooria {n}
+	Series {n}	Sari {n}
+	Type the categories down the side and a column of values per series.	Sisesta kategooriad külje peale ja iga sarja jaoks väärtuste veerg.
+	Categories	Kategooriad
+	Series name	Sarja nimi
+	Remove series	Eemalda sari
+	Remove row	Eemalda rida
+	Add Row	Lisa rida
+	Add Series	Lisa sari
+	Edit\nData	Redigeeri\nandmeid
+	Change\nChart Type	Muuda\ndiagrammi tüüpi
 	Align Text	Joonda tekst
 	Break Link	Katkesta link
 	Click the empty text box the text should continue in (Esc cancels)	Klõpsa tühjal tekstiväljal, kus tekst peaks jätkuma (Esc tühistab)
@@ -1444,6 +1634,20 @@
 	Rotate all text 270°	Pööra kogu teksti 270°
 	Rotate all text 90°	Pööra kogu teksti 90°
 	Stacked	Virnas
+	Accessibility Pane	Ligipääsetavuse paan
+	Alt Text Pane	Asendusteksti paan
+	Alt\nText	Asendus-\ntekst
+	View Alt Text…	Kuva asendustekst…
+	Mark as decorative	Märgi dekoratiivseks
+	Title:	Pealkiri:
+	Errors ({n})	Vead ({n})
+	Warnings ({n})	Hoiatused ({n})
+	Tips ({n})	Näpunäited ({n})
+	No accessibility issues found.	Ligipääsetavuse probleeme ei leitud.
+	Describe what this object shows, for people who can't see it.	Kirjeldage, mida see objekt näitab, neile, kes seda ei näe.
+	Decorative objects only add visual interest: screen readers skip them.	Dekoratiivsed objektid lisavad ainult visuaalset huvi: ekraanilugerid jätavad need vahele.
+	Describe what this table shows, for people who can't see it.	Kirjeldage, mida see tabel näitab, neile, kes seda ei näe.
+	Select a picture, shape, chart or table to describe it.	Valige pilt, kujund, diagramm või tabel, et seda kirjeldada.
 	Document Grid	Dokumendi ruudustik
 	No grid	Ruudustikuta
 	Lines only	Ainult read
@@ -1466,3 +1670,379 @@
 	Do Not Check Spelling or Grammar	Ära kontrolli õigekirja ega grammatikat
 	English (United Kingdom)	Inglise (Ühendkuningriik)
 	Polish	Poola
+
+# Built-in file browser when the system file dialog is unavailable (#576)
+	Documents	Dokumendid
+	Word document	Wordi dokument
+	All files	Kõik failid
+	Recipient lists	Adressaatide loendid
+	The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity.	Süsteemi failidialoog pole saadaval, seega näitab WordCraft enda oma. Süsteemi dialoogi saamiseks paigalda failivalija portaal (näiteks xdg-desktop-portal-gtk) või zenity.
+	Up one level	Taseme võrra üles
+	Home folder	Kodukaust
+	{name} wasn't found.	{name} ei leitud.
+	{name} already exists. Choose Save again to replace it.	{name} on juba olemas. Selle asendamiseks vali uuesti Salvesta.
+	This folder can't be read: {error}	Seda kausta ei saa lugeda: {error}
+	Showing the first {count} items.	Kuvatud on ainult esimesed kirjed: {count}.
+	File name:	Faili nimi:
+	Browse in WordCraft…	Sirvi WordCraftis…
+	Open a file with WordCraft's own browser when the system file dialog doesn't appear.	Ava fail WordCrafti enda failisirvijaga, kui süsteemi failidialoog ei ilmu.
+	Hide White Space	Peida tühi ala lehtede vahel
+	All pages	Kõik leheküljed
+	Current page	Praegune lehekülg
+	Selected pages	Valitud leheküljed
+	Custom range	Kohandatud vahemik
+	All pages in the range	Kõik vahemiku leheküljed
+	Odd pages only	Ainult paaritud leheküljed
+	Even pages only	Ainult paarisleheküljed
+	Copies	Koopiad
+	Collate copies	Järjesta koopiad
+	Pages like 1-3, 5	Leheküljed, nt 1-3, 5
+	{count} of {total} pages will print	Prinditakse {count} lehekülge {total}-st
+	Save these pages as PDF…	Salvesta need leheküljed PDF-ina…
+	The printer, two-sided printing and pages per sheet are chosen in that dialog.	Printer, kahepoolne printimine ja lehekülgi lehe kohta valitakse selles dialoogis.
+	Previous Page	Eelmine lehekülg
+	Print to PDF	Prindi PDF-i
+	Add Shape	Lisa kujund
+	Change Colors	Muuda värve
+	Change Layout	Muuda paigutust
+	Create Graphic	Loo graafika
+	Edit Items	Redigeeri üksusi
+	Layouts	Paigutused
+	Reset Graphic	Lähtesta graafika
+	SmartArt Design	SmartArti kujundus
+	SmartArt Styles	SmartArti laadid
+	Text Pane	Tekstipaan
+	List	Loend
+	Process	Protsess
+	Cycle	Tsükkel
+	Hierarchy	Hierarhia
+	Relationship	Seos
+	Pyramid	Püramiid
+	Basic List	Lihtne loend
+	Basic Process	Lihtne protsess
+	Basic Cycle	Lihtne tsükkel
+	Basic Pyramid	Lihtne püramiid
+	Basic Radial	Lihtne radiaal
+	Basic Matrix	Lihtne maatriks
+	Basic Venn	Lihtne Venni diagramm
+	Shows items of equal weight as blocks in rows.	Näitab võrdse kaaluga üksusi plokkidena ridades.
+	Shows steps in order, left to right, with arrows between them.	Näitab samme järjekorras vasakult paremale, nende vahel nooled.
+	Shows steps that repeat, around a circle.	Näitab korduvaid samme ringi ümber.
+	Shows a tree: each item below the item it belongs to.	Näitab puud: iga üksus on selle üksuse all, kuhu see kuulub.
+	Shows parts that build on each other, largest at the bottom.	Näitab teineteisele toetuvaid osi, suurim all.
+	Shows items around a central idea: the first item is the centre.	Näitab üksusi keskse idee ümber: esimene üksus on keskel.
+	Shows parts of a whole as quadrants.	Näitab terviku osi veeranditena.
+	Shows overlapping ideas as overlapping circles.	Näitab kattuvaid ideid kattuvate ringidena.
+	Accent {n}	Rõhk {n}
+	Colorful	Värviline
+	Insert SmartArt	Lisa SmartArt
+	One line per item. Enter adds an item.	Üks rida üksuse kohta. Sisestusklahv lisab üksuse.
+	Add\nShape	Lisa\nkujund
+	Change\nColors	Muuda\nvärve
+	Reset\nGraphic	Lähtesta\ngraafika
+	Promote to Heading 1	Tõsta pealkirjaks 1
+	Demote to Body Text	Langeta põhitekstiks
+	Move Up	Teisalda üles
+	Move Down	Teisalda alla
+	Collapse	Ahenda
+	Expand or Collapse Heading	Laienda või ahenda pealkiri
+	Select Heading and Content	Vali pealkiri koos sisuga
+	Show Level	Kuva tase
+	Show Level 1	Kuva tase 1
+	Show Level 2	Kuva tase 2
+	Show Level 3	Kuva tase 3
+	Show Level 4	Kuva tase 4
+	Show Level 5	Kuva tase 5
+	Show Level 6	Kuva tase 6
+	Show Level 7	Kuva tase 7
+	Show Level 8	Kuva tase 8
+	Show Level 9	Kuva tase 9
+	Show All Levels	Kuva kõik tasemed
+	All Levels	Kõik tasemed
+	Show First Line Only	Kuva ainult esimene rida
+	Show Text Formatting	Kuva teksti vorming
+	Close Outline View	Sule liigendusvaade
+	Outline State	Liigenduse olek
+	Outlining	Liigendamine
+	Outline Tools	Liigendustööriistad
+	Close Outline\nView	Sule\nliigendusvaade
+	A, B, C, …	A, B, C, …
+	Above the item	Objekti kohal
+	Accessed on	Vaadatud
+	Add New Source…	Lisa uus allikas…
+	Add the chapter number	Lisa peatüki number
+	Atmosphere	Atmosfäär
+	Below the item	Objekti all
+	Book	Raamat
+	Book title	Raamatu pealkiri
+	Caption	Pealdis
+	Caption Numbering	Pealdiste nummerdamine
+	Caption text	Pealdise tekst
+	Caption:	Pealdis:
+	Chapter in a book	Peatükk raamatus
+	Chapters begin at:	Peatükid algavad:
+	Collect entries from:	Kirjed võetakse:
+	Columns:	Veerud:
+	Conference	Konverents
+	Conference paper	Konverentsiartikkel
+	Container Title	Kogumiku pealkiri
+	Create Source	Loo allikas
+	Cross-reference:	Ristviide:
+	Custom Table of Contents…	Kohandatud sisukord…
+	DOI	DOI
+	Day	Päev
+	Delete Label	Kustuta silt
+	Edit Source	Muuda allikat
+	Edition	Väljaanne
+	Edit…	Muuda…
+	Entry marked.	Kirje märgitud.
+	Example: {sample}	Näide: {sample}
+	Figure	Joonis
+	Film	Film
+	Heading styles (levels 1–{n})	Pealkirjalaadid (tasemed 1–{n})
+	Heading {n}	Pealkiri {n}
+	I, II, III, …	I, II, III, …
+	Include page numbers	Lisa leheküljenumbrid
+	Indented	Taandega
+	Institution	Asutus
+	Ionosphere	Ionosfäär
+	Issue	Number
+	Journal	Ajakiri
+	Label:	Silt:
+	Last, First; Last, First	Perenimi, Eesnimi; Perenimi, Eesnimi
+	Leave the label out of the caption	Jäta silt pealdisest välja
+	Letter headings	Tähepealkirjad
+	Levels:	Tasemed:
+	Link entries to their headings	Lingi kirjed pealkirjadega
+	Made from the author and year when empty	Tühjana tehakse autorist ja aastast
+	Magazine or newspaper article	Ajakirja- või ajaleheartikkel
+	Main entry:	Põhikirje:
+	Mark	Märgi
+	Mark All	Märgi kõik
+	Mark Entry…	Märgi kirje…
+	Mark Index Entry	Märgi registrikirje
+	Mesosphere	Mesosfäär
+	Month	Kuu
+	New Label	Uus silt
+	New Label…	Uus silt…
+	New…	Uus…
+	No sources yet.	Allikaid veel pole.
+	Numbering…	Nummerdamine…
+	Options…	Suvandid…
+	Other	Muu
+	Other styles and their TOC level:	Muud laadid ja nende sisukorratase:
+	Outline levels	Liigendustasemed
+	Page number style	Leheküljenumbri laad
+	Page numbers at the right margin	Leheküljenumbrid paremas servas
+	Page title	Lehe pealkiri
+	Pages of bookmark:	Järjehoidja leheküljed:
+	Periodical	Perioodika
+	Position:	Asukoht:
+	Publisher	Kirjastus
+	Run-in	Jooksev
+	See	Vt
+	Separator:	Eraldaja:
+	Show every bibliography field	Näita kõiki bibliograafiavälju
+	Site name	Saidi nimi
+	Source Manager	Allikahaldur
+	Source type:	Allika tüüp:
+	Sources in this document:	Selle dokumendi allikad:
+	Styles:	Laadid:
+	Subentry:	Alamkirje:
+	TC entry fields	TC-kirjeväljad
+	Tab leader:	Tabelduse täide:
+	Table of Contents Options	Sisukorra suvandid
+	Table of Contents Styles	Sisukorra laadid
+	Tag	Silt
+	This page	See lehekülg
+	Title	Pealkiri
+	Type:	Tüüp:
+	URL	URL
+	Volume	Köide
+	Website	Veebisait
+	Year	Aasta
+	a, b, c, …	a, b, c, …
+	i, ii, iii, …	i, ii, iii, …
+	{n} entries marked.	Märgitud kirjeid: {n}.
+	Lasso Select	Lassoga valimine
+	Move Selected Ink	Teisalda valitud tint
+	Delete Selected Ink	Kustuta valitud tint
+	Recolor Selected Ink	Muuda valitud tindi värvi
+	Add Pen	Lisa pliiats
+	Remove Pen	Eemalda pliiats
+	Ink to Shape	Käsikiri kujundiks
+	Convert to Shapes	Teisenda kujunditeks
+	Ink Replay	Esita käsikiri
+	Add\nPen	Lisa\npliiats
+	Rewind	Keri algusesse
+	Forward	Edasi
+	Stroke {n} of {total}	Joon {n}/{total}
+	Use wildcards	Kasuta metamärke
+	Special	Erimärgid
+	Match prefix	Sobita eesliide
+	Match suffix	Sobita järelliide
+	Ignore punctuation characters	Eira kirjavahemärke
+	Ignore white-space characters	Eira tühikumärke
+	Regular expressions	Regulaaravaldised
+	Search Options	Otsingusuvandid
+	Tab Character	Tabeldusmärk
+	Any Character	Suvaline märk
+	Any Digit	Suvaline number
+	Any Letter	Suvaline täht
+	Caret Character	Katusmärk
+	Section Character	Paragrahvi märk
+	Paragraph Character	Lõigu sümbol
+	Graphic	Pilt
+	Manual Line Break	Käsitsi reapiir
+	Manual Page Break	Käsitsi lehepiir
+	Section Break	Jaotisepiir
+	White Space	Tühimärk
+	Clipboard Contents	Lõikelaua sisu
+	Find What Text	Otsitav tekst
+	Find What Expression	Otsitav avaldis
+	Character in Range	Märk vahemikus
+	Beginning of Word	Sõna algus
+	End of Word	Sõna lõpp
+	Expression	Avaldis
+	Not	Mitte
+	Num Occurrences	Korduste arv
+	Previous 1 or More	Eelmine 1 või rohkem korda
+	0 or More Characters	0 või rohkem märki
+	Move with Text	Liigu tekstiga
+	Fix Position on Page	Fikseeri asukoht lehel
+
+# WordArt and connectors (#416).
+	WordArt Styles	WordArti laadid
+	Text Fill	Teksti täide
+	Text Outline	Teksti kontuur
+	Transform	Teisenda
+	No Fill	Täiteta
+	No Outline	Kontuurita
+	Reflection	Peegeldus
+	No Reflection	Peegelduseta
+	No Transform	Teisenduseta
+	Connect Shapes	Ühenda kujundid
+	Straight Connector	Sirge ühendusjoon
+	Straight Arrow Connector	Sirge noolega ühendusjoon
+	Elbow Connector	Nurgeline ühendusjoon
+	Elbow Arrow Connector	Nurgeline noolega ühendusjoon
+	Curved Connector	Kaardus ühendusjoon
+	Curved Arrow Connector	Kaardus noolega ühendusjoon
+	Arch Up	Kaar üles
+	Arch Down	Kaar alla
+	Slant Up	Kalle üles
+	Slant Down	Kalle alla
+	Inflate	Paisutus
+	Deflate	Kokkutõmme
+	Chevron Up	Sparre üles
+	Chevron Down	Sparre alla
+	Triangle Up	Kolmnurk üles
+	Triangle Down	Kolmnurk alla
+	Solid Accent	Ühtlane rõhuvärv
+	Light with Outline	Hele kontuuriga
+	Hollow	Õõnes
+	Accent Gradient	Rõhuvärvi üleminek
+	Dark with Shadow	Tume varjuga
+	Soft Glow	Pehme kuma
+	Accent with Reflection	Rõhuvärv peegeldusega
+	Warm Gradient with Outline	Soe üleminek kontuuriga
+	Developer	Arendaja
+	Controls	Juhtelemendid
+	Rich Text Content Control	Vormindatud teksti sisujuhtelement
+	Plain Text Content Control	Lihtteksti sisujuhtelement
+	Picture Content Control	Pildi sisujuhtelement
+	Building Block Gallery Content Control	Ehitusplokkide galerii sisujuhtelement
+	Check Box Content Control	Märkeruudu sisujuhtelement
+	Combo Box Content Control	Liitboksi sisujuhtelement
+	Drop-Down List Content Control	Ripploendi sisujuhtelement
+	Date Picker Content Control	Kuupäevavalija sisujuhtelement
+	Repeating Section Content Control	Korduva jaotise sisujuhtelement
+	Design Mode	Kujundusrežiim
+	Content Control at Selection	Valiku sisujuhtelement
+	Toggle Check Box	Lülita märkeruutu
+	Choose List Item	Vali loendi üksus
+	Set Date	Määra kuupäev
+	Remove Content Control	Eemalda sisujuhtelement
+	Content Control Properties	Sisujuhtelemendi atribuudid
+	Placeholder text	Kohatäite tekst
+	Can't be deleted	Ei saa kustutada
+	Contents can't be edited	Sisu ei saa redigeerida
+	Remove the control once edited	Eemalda juhtelement pärast redigeerimist
+	Allow line breaks	Luba reavahetused
+	Date format	Kuupäeva vorming
+	Checked symbol	Märgitud sümbol
+	Unchecked symbol	Märkimata sümbol
+	List entries	Loendi kirjed
+	Display text	Kuvatav tekst
+	Value	Väärtus
+	Today	Täna
+	Put the caret in a content control first.	Pange kursor esmalt sisujuhtelementi.
+	Add line numbering	Lisa reanummerdus
+	Add to Document	Lisa dokumenti
+	Address labels	Aadressisildid
+	Arabic	Araabia
+	Auto	Automaatne
+	Automatically hyphenate document	Poolita dokumenti automaatselt
+	Chinese (Simplified)	Hiina (lihtsustatud)
+	Chinese (Traditional)	Hiina (traditsiooniline)
+	Column:	Veerg:
+	Count by:	Samm:
+	Czech	Tšehhi
+	Danish	Taani
+	Delivery address:	Saaja aadress:
+	Detect language automatically	Tuvasta keel automaatselt
+	Do not check spelling or grammar	Ära kontrolli õigekirja ega grammatikat
+	Dutch	Hollandi
+	Envelope size:	Ümbriku suurus:
+	Estonian	Eesti
+	Finnish	Soome
+	French (France)	Prantsuse (Prantsusmaa)
+	From text:	Tekstist:
+	Full page of the same label	Terve leht sama silti
+	German (Germany)	Saksa (Saksamaa)
+	Greek	Kreeka
+	Hebrew	Heebrea
+	Hyphenate at:	Poolita kohast:
+	Hyphenate words in CAPS	Poolita SUURTÄHTEDES sõnu
+	Hyphenation Options…	Poolitussätted…
+	Hyphenation zone:	Poolitusala:
+	Italian	Itaalia
+	Japanese	Jaapani
+	Korean	Korea
+	Limit consecutive hyphens to:	Järjestikuseid poolitusi kuni:
+	Line Numbering Options…	Reanummerduse sätted…
+	Manual Hyphenation	Käsitsi poolitamine
+	Manual hyphenation is complete.	Käsitsi poolitamine on lõpetatud.
+	Manual…	Käsitsi…
+	Mark selected text as:	Märgi valitud tekst keeleks:
+	New Document	Uus dokument
+	No limit	Piiranguta
+	Norwegian (Bokmål)	Norra (bokmål)
+	Numbering:	Nummerdus:
+	Omit	Jäta välja
+	One label per recipient	Üks silt saaja kohta
+	Portuguese (Brazil)	Portugali (Brasiilia)
+	Portuguese (Portugal)	Portugali (Portugal)
+	Return address labels	Saatja aadressi sildid
+	Return address:	Saatja aadress:
+	Row:	Rida:
+	Russian	Vene
+	Serbian (Cyrillic)	Serbia (kirillitsa)
+	Serbian (Latin)	Serbia (ladina)
+	Set As Default	Määra vaikeväärtuseks
+	Shipping labels	Saatmissildid
+	Single label	Üks silt
+	Spanish (Mexico)	Hispaania (Mehhiko)
+	Spanish (Spain)	Hispaania (Hispaania)
+	Swedish	Rootsi
+	Turkish	Türgi
+	Ukrainian	Ukraina
+	{language} is now the document's default language.	{language} on nüüd dokumendi vaikekeel.
+	Visual effects	Visuaalefektid
+	Animation effects:	Animatsiooniefektid:
+	On	Sees
+	Off	Väljas
+	Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.	Sujuv kerimine ja suumimine ning menüüde ja nuppude sujuv ilmumine. Valikuga „Väljas“ kuvatakse iga muudatus kohe.
+	Your system has animation effects turned on.	Süsteemis on animatsiooniefektid sisse lülitatud.
+	Your system has animation effects turned off.	Süsteemis on animatsiooniefektid välja lülitatud.
+	Your system doesn't report an animation setting, so animation effects stay on.	Süsteem ei teata animatsiooniseadet, seega jäävad animatsiooniefektid sisse.
diff --git a/crates/ui-egui/src/i18n/ja.tsv b/crates/ui-egui/src/i18n/ja.tsv
index 3c8b7f0d6a..18bcc7af17 100644
--- a/crates/ui-egui/src/i18n/ja.tsv
+++ b/crates/ui-egui/src/i18n/ja.tsv
@@ -48,12 +48,15 @@
 	Arrange\nAll	整列
 	Arrow	矢印
 	Artistic Effects	アート効果
+	As you type	入力中
+	Asian text font:	アジア文字のフォント:
 	Asian Typography	アジア文字の組版
 	Author	作成者
 	AutoCorrect Options	オートコレクトのオプション
 	AutoFit	自動調整
 	AutoFit Contents	文字列の幅に合わせる
 	AutoFit Window	ウィンドウ幅に合わせる
+	AutoSave writes your changes to the file a moment after you stop typing.	自動保存は、入力を止めて少したつと変更をファイルに書き込みます。
 	Automatic	自動
 	Automatic ({language})	自動（{language}）
 	Automatic follows your system's language. Menus and commands change; your documents don't.	「自動」はシステムの言語に従います。メニューとコマンドの表示が変わり、文書の内容は変わりません。
@@ -64,13 +67,17 @@
 	AutoSave failed: {error}. Save the document to turn AutoSave back on.	自動保存できませんでした: {error}。文書を保存し直すと、自動保存が再開します。
 	Balloons	吹き出し
 	Bottom Margin	下余白
+	Centimeters	センチメートル
+	Check spelling as you type	入力中にスペル チェックを行う
 	Click a border between two cells to merge them. Esc stops.	2 つのセルの間の境界線をクリックすると結合します。Esc で終了します。
 	Bullet	行頭文字
 	By author	校閲者別
 	Changed lines:	変更された行:
 	Click level to modify:	変更するレベルをクリック:
+	Click to switch back to inserting	クリックすると挿入モードに戻ります
 	Color only	色のみ
 	Compress punctuation at the start of a line	行頭の約物を詰める
+	Custom dictionary	ユーザー辞書
 	Dark page (white text on black)	ダーク ページ (黒地に白い文字)
 	Drag a rectangle to draw a table, or a line across cells to split them. Esc stops.	四角形をドラッグして表を描くか、セルを横切る線を引いて分割します。Esc で終了します。
 	Draw Table	表を描画
@@ -81,10 +88,22 @@
 	Enter formatting for number:	番号の書式:
 	Follow number with:	番号に続く文字:
 	Formatting	書式
+	Formatting marks	編集記号
+	Hidden text	隠し文字
+	Ignore web and file addresses	Web アドレスとファイル パスを無視する
+	Ignore words in capitals	すべて大文字の単語を無視する
+	Ignore words with numbers	数字を含む単語を無視する
+	Inches	インチ
+	Formatting exceptions	書式の例外
 	Include level number from:	含めるレベルの番号:
+	Initials:	イニシャル:
 	Ink	インク
 	Insertions and Deletions	挿入と削除
 	Insertions:	挿入された箇所:
+	Interface	インターフェイス
+	Interface language	表示言語
+	Inside:	内側:
+	Latin text font:	ラテン文字のフォント:
 	Left border	左罫線
 	Left Margin	左余白
 	Indents and Spacing	インデントと間隔
@@ -92,13 +111,33 @@
 	Line breaking	行の分割
 	Link level to style:	レベルに対応付けるスタイル:
 	List Definition	リストの定義
+	Mark grammar errors as you type	入力中に文法の誤りに印を付ける
+	Measurement units:	単位:
+	Millimeters	ミリメートル
+	Mirror indents	左右対称のインデント
 	More templates →	その他のテンプレート →
+	New comments and tracked changes are recorded under this name and these initials.	新しいコメントと変更履歴は、この名前とイニシャルで記録されます。
+	New word	新しい単語
 	No templates match your search.	検索に一致するテンプレートはありません。
+	No words yet. Add to Dictionary on a misspelled word puts it here.	まだ単語はありません。スペルミスの単語で [辞書に追加] を選ぶと、ここに追加されます。
 	Nothing	なし
 	Number alignment:	番号の配置:
 	Number format	番号書式
 	Number style for this level:	このレベルの番号の種類:
 	Outside border	外側の罫線
+	Overtype	上書き
+	Overtype (typing replaces the characters after the caret)	上書き (入力した文字がカーソルの後ろの文字を置き換えます)
+	Page display	ページの表示
+	Paragraph marks	段落記号
+	Personalize	個人設定
+	Picas	パイカ
+	Points	ポイント
+	Print the page color	ページの色を印刷する
+	Printing	印刷
+	Proofing language	文章校正の言語
+	Recent documents to show:	表示する最近使ったドキュメントの数:
+	Remove	削除
+	Outside:	外側:
 	Reopen	再度開く
 	Restart list after:	リストを振り直すレベル:
 	Right border	右罫線
@@ -108,9 +147,9 @@
 	Distribute spacing	間隔を均等に配置
 	Offset (pt):	オフセット (pt):
 	Phonetic Guide	ルビ
-	Remove	削除
 	Right (vertical)	右 (縦書き)
 	Ruby text:	ルビ文字:
+	Save documents	ドキュメントの保存
 	Search for templates	テンプレートを検索
 	Show all revisions inline	すべての変更履歴を本文中に表示
 	Show documents with their colours inverted, like View › Switch Modes. Saving, printing and PDFs are unchanged.	表示 › モードの切り替えと同様に、文書の色を反転して表示します。保存、印刷、PDF は変わりません。
@@ -138,6 +177,11 @@
 	Border Painter	罫線の書式設定
 	Border\nPainter	罫線の書式設定
 	Borders	罫線
+	Show the mini toolbar when text is selected	テキストを選択したときにミニ ツール バーを表示する
+	Spaces	スペース
+	Spelling	スペル チェック
+	Spelling and grammar are checked in English (United States).	スペルと文法は英語 (米国) でチェックされます。
+	Tab characters	タブ
 	Tab stop position:	タブ位置:
 	Default tab stops:	既定のタブ間隔:
 	Tab stops to be cleared:	削除するタブ:
@@ -148,6 +192,10 @@
 	Set	設定
 	Page Border	ページ罫線の設定
 	Apply to:	適用先:
+	These marks show even when Show/Hide ¶ is off.	これらの記号は、[編集記号の表示/非表示 ¶] がオフでも表示されます。
+	Typing replaces selected text	入力時に選択文字列を置き換える
+	Update fields before printing	印刷前にフィールドを更新する
+	Use the Insert key to switch overtype on and off	Insert キーで上書きのオンとオフを切り替える
 	Whole document	文書全体
 	This section	このセクション
 	Fill	塗りつぶし
@@ -332,6 +380,7 @@
 	Export PDF	PDF にエクスポート
 	Exported {path}	{path} にエクスポートしました
 	Extend Selection	選択範囲の拡張
+	Extend Selection by Units	単位ごとに選択範囲を拡張
 	Field	フィールド
 	File	ファイル
 	Find	検索
@@ -737,6 +786,9 @@
 	Show only comments and formatting in balloons	コメントと書式のみを吹き出しに表示
 	Show revisions in balloons	変更履歴を吹き出しに表示
 	Show rulers	ルーラーを表示する
+	Animation	アニメーション
+	Animate the caret (it glides and fades)	カーソルをアニメーション表示する（滑らかに移動してフェードする）
+	On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off.	オン: 入力や矢印キーの操作でカーソルが新しい位置へ滑らかに移動し、点滅もフェードします。オフ: カーソルは瞬時に移動し、点滅は表示と非表示が切り替わるだけです。
 	Show the community button in the title bar	タイトル バーにコミュニティ ボタンを表示する
 	Show/Hide ¶	編集記号の表示/非表示 ¶
 	Show\nComments	コメントの表示
@@ -879,10 +931,10 @@
 	Wide	広い
 	Widow/Orphan Control	改ページ時 1 行残して段落を区切らない
 	Widow/Orphan control	改ページ時 1 行残して段落を区切らない
-	Wildcards (regex)	ワイルドカード（正規表現）
 	Window	ウィンドウ
 	Word Count	文字カウント
 	Word document (*.docx)	Word 文書 (*.docx)
+	Word XML Document (*.xml)	Word XML ドキュメント (*.xml)
 	Word Left	前の単語へ
 	Word Right	次の単語へ
 	WordArt	ワードアート
@@ -1348,8 +1400,86 @@
 	Selected Fields	選択したフィールド
 	Edit Field…	フィールドの編集…
 	Formatted	書式変更
+	Deleted	削除
 	Interface size:	表示サイズ:
 	Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate.	リボン、メニュー、ダイアログを、システムの表示倍率に加えて拡大または縮小します。文書のズームは別に設定します。
+	Resize Table by Dragging	ドラッグで表のサイズを変更
+	Print Markup	変更履歴とコメントを印刷
+	Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text.	PDF、印刷、画像では各ページの横にコメントと変更履歴を表示し、Web ページ、Markdown、テキストでは末尾にコメント一覧を付けます。
+
+# Compare / Combine, AutoCorrect Options and Restrict Editing (#412)
+	1. Formatting restrictions	1. 書式の制限
+	2. Editing restrictions	2. 編集の制限
+	3. Start enforcement	3. 保護の開始
+	<< Less	<< 表示を減らす
+	Another file	別のファイル
+	Apply as you type	入力中に適用
+	AutoCorrect	オートコレクト
+	AutoFormat As You Type	入力オートフォーマット
+	Automatic bulleted lists	箇条書き (自動)
+	Automatic numbered lists	段落番号 (自動)
+	Border lines	罫線
+	Capitalize first letter of sentences	文の先頭文字を大文字にする
+	Capitalize first letter of table cells	表のセルの先頭文字を大文字にする
+	Capitalize names of days	曜日の先頭文字を大文字にする
+	Case changes	大文字/小文字の変更
+	Character level	文字単位
+	Checked styles are allowed:	チェックしたスタイルを使用可能:
+	Combine Documents	文書の組み込み
+	Compare Documents	文書の比較
+	Compared: {changes} changes	比較しました: 変更 {changes} 件
+	Comparing with another file needs the desktop app.	別のファイルとの比較にはデスクトップ版が必要です。
+	Comparison settings	比較の設定
+	Don't capitalize after:	次の後は大文字にしない:
+	Editing in this document is restricted.	この文書の編集は制限されています。
+	Every change is recorded as a tracked change.	すべての変更が変更履歴として記録されます。
+	Everyone	すべてのユーザー
+	Exceptions (optional)	例外 (省略可能)
+	Exceptions…	例外…
+	Fields	フィールド
+	Filling in forms	フォームへの入力
+	Find Next Editable Region	次の編集可能な範囲を検索
+	Footnotes and endnotes	脚注と文末脚注
+	Formatting, case changes, white space and tables are compared; the other settings are kept for later.	書式、大文字/小文字、空白、表を比較します。その他の設定は今後の対応です。
+	Fractions (1/2) as fraction characters (½)	分数 (1/2) を分数文字 (½) に
+	Headers and footers	ヘッダーとフッター
+	Hyphens (--) as dashes (—)	ハイフン (--) をダッシュ (—) に
+	In equations, typing a name after a backslash replaces it with its symbol.	数式では、円記号 (バックスラッシュ) の後に名前を入力すると記号に置き換わります。
+	Internet addresses as links	インターネットのアドレスをリンクに
+	Label changes with:	変更者のラベル:
+	Limit formatting to a selection of styles	書式を選択したスタイルに制限する
+	Math AutoCorrect	数式オートコレクト
+	More >>	オプション >>
+	Moves	移動
+	New document	新規文書
+	No changes (read only)	変更不可 (読み取り専用)
+	Only allow this kind of editing:	次の種類の編集のみを許可:
+	Only comments can be added, except in regions marked editable.	編集可能とマークされた範囲を除き、コメントの追加のみ可能です。
+	Only form fields can be filled in.	フォーム フィールドへの入力のみ可能です。
+	Only the allowed styles can be applied.	使用を許可されたスタイルだけを適用できます。
+	Ordinals (1st) as superscript	序数 (1st) を上付き文字に
+	Original document	元の文書
+	This password type isn't supported.	この種類のパスワードはサポートされていません。
+	Replace as you type	入力中に自動で変更
+	Replace text as you type	入力中に自動修正する
+	Replace:	修正文字列:
+	Revised document	変更された文書
+	Select text, then tick who can still edit it.	テキストを選択し、編集できるユーザーをチェックします。
+	Settings…	設定…
+	Show changes at:	変更の表示単位:
+	Show changes in:	変更の表示先:
+	Smart quotes instead of straight quotes	左右の区別がない引用符を区別がある引用符に
+	Start Enforcing Protection	保護を開始
+	Stop Protection	保護の中止
+	Text boxes	テキスト ボックス
+	The document is read only, except for regions marked editable.	編集可能とマークされた範囲を除き、この文書は読み取り専用です。
+	The password is optional; without it anyone can stop the protection.	パスワードは省略できます。省略すると、誰でも保護を中止できます。
+	This document	この文書
+	Tracked changes	変更履歴
+	Type the password to stop the protection.	保護を中止するにはパスワードを入力してください。
+	White space	空白
+	With:	修正後の文字列:
+	Word level	単語単位
 	In Line with Text	行内
 	Square	四角形
 	Through	内部
@@ -1396,6 +1526,36 @@
 	New Group	新しいグループ
 	Rename…	名前の変更…
 	Ribbon and Quick Access Toolbar:	リボンとクイック アクセス ツール バー:
+	Add Font…	フォントの追加…
+	Added Fonts	追加したフォント
+	Remove Added Font	追加したフォントの削除
+	Recent Colors	最近使用した色
+	More Colors…	その他の色…
+	Standard	標準
+	Current	現在
+	Colors:	色:
+	Color model:	カラー モデル:
+	Red:	赤:
+	Green:	緑:
+	Blue:	青:
+	Hue:	色合い:
+	Sat:	鮮やかさ:
+	Lum:	明るさ:
+	Hex:	16 進数:
+	Accessibility Pane	アクセシビリティ ウィンドウ
+	Alt Text Pane	代替テキスト ウィンドウ
+	Alt\nText	代替\nテキスト
+	View Alt Text…	代替テキストを表示…
+	Mark as decorative	装飾用にする
+	Title:	タイトル:
+	Errors ({n})	エラー ({n})
+	Warnings ({n})	警告 ({n})
+	Tips ({n})	ヒント ({n})
+	No accessibility issues found.	アクセシビリティの問題は見つかりませんでした。
+	Describe what this object shows, for people who can't see it.	このオブジェクトが示す内容を、見ることができない人のために説明してください。
+	Decorative objects only add visual interest: screen readers skip them.	装飾用のオブジェクトは見た目を整えるだけなので、スクリーン リーダーは読み上げません。
+	Describe what this table shows, for people who can't see it.	この表が示す内容を、見ることができない人のために説明してください。
+	Select a picture, shape, chart or table to describe it.	説明する画像、図形、グラフ、または表を選択してください。
 	Document Grid	文書グリッド
 	No grid	グリッドなし
 	Lines only	行のみ
@@ -1405,6 +1565,39 @@
 	Lines per page:	1 ページの行数:
 	Moved from	移動元
 	Moved to	移動先
+	Developer	開発
+	Controls	コントロール
+	Rich Text Content Control	リッチ テキスト コンテンツ コントロール
+	Plain Text Content Control	プレーン テキスト コンテンツ コントロール
+	Picture Content Control	画像コンテンツ コントロール
+	Building Block Gallery Content Control	構成要素ギャラリー コンテンツ コントロール
+	Check Box Content Control	チェック ボックス コンテンツ コントロール
+	Combo Box Content Control	コンボ ボックス コンテンツ コントロール
+	Drop-Down List Content Control	ドロップダウン リスト コンテンツ コントロール
+	Date Picker Content Control	日付選択コンテンツ コントロール
+	Repeating Section Content Control	繰り返しセクション コンテンツ コントロール
+	Design Mode	デザイン モード
+	Content Control at Selection	選択位置のコンテンツ コントロール
+	Toggle Check Box	チェック ボックスの切り替え
+	Choose List Item	リスト項目を選択
+	Set Date	日付を設定
+	Remove Content Control	コンテンツ コントロールの削除
+	Content Control Properties	コンテンツ コントロールのプロパティ
+	Title	タイトル
+	Tag	タグ
+	Placeholder text	プレースホルダー テキスト
+	Can't be deleted	削除できない
+	Contents can't be edited	内容を編集できない
+	Remove the control once edited	編集したらコントロールを削除する
+	Allow line breaks	改行を許可する
+	Date format	日付の形式
+	Checked symbol	オンの記号
+	Unchecked symbol	オフの記号
+	List entries	リストの項目
+	Display text	表示テキスト
+	Value	値
+	Today	今日
+	Put the caret in a content control first.	先にカーソルをコンテンツ コントロールに置いてください。
 	Right-to-Left Table	右から左の表
 	Right-to-Left Section	右から左のセクション
 	Table direction:	表の方向:
@@ -1432,6 +1625,50 @@
 	Enlarge symbol	記号を拡大
 	Enclosure	囲い
 	Circle	円
+	Templates	テンプレート
+	Templates and Add-ins	テンプレートとアドイン
+	Attach Template	テンプレートの添付
+	Detach Template	テンプレートの解除
+	Automatically Update Document Styles	文書のスタイルを自動的に更新
+	Update Styles from Template	テンプレートからスタイルを更新
+	Organizer	オーガナイザー
+	Copy Styles	スタイルのコピー
+	Rename Style	スタイル名の変更
+	Document template:	文書テンプレート:
+	Attach…	添付…
+	Automatically update document styles	文書のスタイルを自動的に更新する
+	Organizer…	オーガナイザー…
+	Change Chart Type	グラフの種類の変更
+	Chart Design	グラフのデザイン
+	Type	種類
+	Edit Data	データの編集
+	Chart Title	グラフ タイトル
+	Chart Layouts	グラフのレイアウト
+	Add Chart Element	グラフ要素の追加
+	Legend	凡例
+	Data Labels	データ ラベル
+	Above Chart	グラフの上
+	Insert Chart	グラフの挿入
+	Clustered Column	集合縦棒
+	Stacked Column	積み上げ縦棒
+	Clustered Bar	集合横棒
+	Stacked Bar	積み上げ横棒
+	Area	面
+	Pie	円
+	Doughnut	ドーナツ
+	Scatter	散布図
+	“{text}” ({row}, {series}) isn't a number.	「{text}」（{row}、{series}）は数値ではありません。
+	Category {n}	カテゴリ {n}
+	Series {n}	系列 {n}
+	Type the categories down the side and a column of values per series.	左端の列にカテゴリを、系列ごとに 1 列ずつ値を入力します。
+	Categories	カテゴリ
+	Series name	系列名
+	Remove series	系列を削除
+	Remove row	行を削除
+	Add Row	行の追加
+	Add Series	系列の追加
+	Edit\nData	データの\n編集
+	Change\nChart Type	グラフの種類\nの変更
 	Align Text	文字の配置
 	Create Link	リンクの作成
 	Break Link	リンクの解除
@@ -1456,3 +1693,346 @@
 	English (United Kingdom)	英語（英国）
 	Polish	ポーランド語
 	Do Not Check Spelling or Grammar	スペル チェックと文章校正を行わない
+
+# Built-in file browser when the system file dialog is unavailable (#576)
+	Documents	ドキュメント
+	Word document	Word 文書
+	All files	すべてのファイル
+	Recipient lists	宛先リスト
+	The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity.	システムのファイル ダイアログを利用できないため、WordCraft 独自のダイアログを表示しています。システムのダイアログを使うには、ファイル選択ポータル (xdg-desktop-portal-gtk など) または zenity をインストールしてください。
+	Up one level	1 つ上のフォルダー
+	Home folder	ホーム フォルダー
+	{name} wasn't found.	{name} が見つかりません。
+	{name} already exists. Choose Save again to replace it.	{name} は既に存在します。置き換えるには、もう一度 [保存] を選んでください。
+	This folder can't be read: {error}	このフォルダーを読み取れません: {error}
+	Showing the first {count} items.	最初の {count} 項目を表示しています。
+	File name:	ファイル名:
+	Browse in WordCraft…	WordCraft で参照…
+	Open a file with WordCraft's own browser when the system file dialog doesn't appear.	システムのファイル ダイアログが表示されないときに、WordCraft 独自のブラウザーでファイルを開きます。
+	Hide White Space	余白を非表示
+	All pages	すべてのページ
+	Current page	現在のページ
+	Selected pages	選択したページ
+	Custom range	ページ範囲を指定
+	All pages in the range	範囲内のすべてのページ
+	Odd pages only	奇数ページのみ
+	Even pages only	偶数ページのみ
+	Copies	部数
+	Collate copies	部単位で印刷
+	Pages like 1-3, 5	ページ指定(例: 1-3, 5)
+	{count} of {total} pages will print	{total} ページ中 {count} ページを印刷します
+	Save these pages as PDF…	このページを PDF として保存…
+	The printer, two-sided printing and pages per sheet are chosen in that dialog.	プリンター、両面印刷、1 枚あたりのページ数は、そのダイアログで選択します。
+	Previous Page	前のページ
+	Print to PDF	PDF に印刷
+	Add Shape	図形の追加
+	Change Colors	色の変更
+	Change Layout	レイアウトの変更
+	Create Graphic	グラフィックの作成
+	Edit Items	項目の編集
+	Layouts	レイアウト
+	Reset Graphic	グラフィックのリセット
+	SmartArt Design	SmartArt のデザイン
+	SmartArt Styles	SmartArt のスタイル
+	Text Pane	テキスト ウィンドウ
+	List	リスト
+	Process	手順
+	Cycle	循環
+	Hierarchy	階層構造
+	Relationship	関係
+	Pyramid	ピラミッド
+	Basic List	基本リスト
+	Basic Process	基本ステップ
+	Basic Cycle	基本循環
+	Basic Pyramid	基本ピラミッド
+	Basic Radial	基本放射
+	Basic Matrix	基本マトリックス
+	Basic Venn	基本ベン図
+	Shows items of equal weight as blocks in rows.	同じ重みの項目をブロックとして行に並べて表示します。
+	Shows steps in order, left to right, with arrows between them.	手順を左から右へ順に、矢印でつないで表示します。
+	Shows steps that repeat, around a circle.	繰り返す手順を円の周りに表示します。
+	Shows a tree: each item below the item it belongs to.	ツリーを表示します。各項目は所属する項目の下に置かれます。
+	Shows parts that build on each other, largest at the bottom.	積み重なる部分を表示します。最も大きいものが一番下です。
+	Shows items around a central idea: the first item is the centre.	中心となる考えの周りに項目を表示します。最初の項目が中心です。
+	Shows parts of a whole as quadrants.	全体の各部分を四分割で表示します。
+	Shows overlapping ideas as overlapping circles.	重なり合う考えを重なる円で表示します。
+	Accent {n}	アクセント {n}
+	Colorful	カラフル
+	Insert SmartArt	SmartArt の挿入
+	One line per item. Enter adds an item.	1 行に 1 項目。Enter キーで項目を追加します。
+	Add\nShape	図形の\n追加
+	Change\nColors	色の\n変更
+	Reset\nGraphic	グラフィックの\nリセット
+	Promote to Heading 1	見出し 1 に設定
+	Demote to Body Text	本文に設定
+	Move Up	上へ移動
+	Move Down	下へ移動
+	Collapse	折りたたみ
+	Expand or Collapse Heading	見出しの展開/折りたたみ
+	Select Heading and Content	見出しと内容を選択
+	Show Level	レベルの表示
+	Show Level 1	レベル 1 を表示
+	Show Level 2	レベル 2 を表示
+	Show Level 3	レベル 3 を表示
+	Show Level 4	レベル 4 を表示
+	Show Level 5	レベル 5 を表示
+	Show Level 6	レベル 6 を表示
+	Show Level 7	レベル 7 を表示
+	Show Level 8	レベル 8 を表示
+	Show Level 9	レベル 9 を表示
+	Show All Levels	すべてのレベルを表示
+	All Levels	すべてのレベル
+	Show First Line Only	1 行目のみ表示
+	Show Text Formatting	文字列の書式を表示
+	Close Outline View	アウトライン表示を閉じる
+	Outline State	アウトラインの状態
+	Outlining	アウトライン
+	Outline Tools	アウトライン ツール
+	Close Outline\nView	アウトライン表示\nを閉じる
+	A, B, C, …	A, B, C, …
+	Above the item	項目の上
+	Accessed on	アクセス日
+	Add New Source…	新しい資料文献の追加…
+	Add the chapter number	章番号を付ける
+	Atmosphere	大気
+	Below the item	項目の下
+	Book	書籍
+	Book title	書籍名
+	Caption	図表番号
+	Caption Numbering	図表番号の書式
+	Caption text	図表番号の文字列
+	Caption:	図表番号:
+	Chapter in a book	書籍の章
+	Chapters begin at:	章の開始:
+	Collect entries from:	項目の取得元:
+	Columns:	段数:
+	Conference	会議
+	Conference paper	会議論文
+	Container Title	掲載元の名前
+	Create Source	資料文献の作成
+	Cross-reference:	相互参照:
+	Custom Table of Contents…	ユーザー設定の目次…
+	DOI	DOI
+	Day	日
+	Delete Label	ラベル削除
+	Edit Source	資料文献の編集
+	Edition	版
+	Edit…	編集…
+	Entry marked.	項目を登録しました。
+	Example: {sample}	例: {sample}
+	Figure	図
+	Film	映画
+	Heading styles (levels 1–{n})	見出しスタイル (レベル 1–{n})
+	Heading {n}	見出し {n}
+	I, II, III, …	I, II, III, …
+	Include page numbers	ページ番号を含める
+	Indented	インデント
+	Institution	機関
+	Ionosphere	電離圏
+	Issue	号
+	Journal	学術誌
+	Label:	ラベル:
+	Last, First; Last, First	姓, 名; 姓, 名
+	Leave the label out of the caption	ラベルを図表番号に含めない
+	Letter headings	文字見出し
+	Levels:	レベル:
+	Link entries to their headings	項目を見出しにリンクする
+	Made from the author and year when empty	空欄なら著者と年から作成
+	Magazine or newspaper article	雑誌・新聞の記事
+	Main entry:	主項目:
+	Mark	登録
+	Mark All	すべて登録
+	Mark Entry…	索引登録…
+	Mark Index Entry	索引登録
+	Mesosphere	中間圏
+	Month	月
+	New Label	新しいラベル
+	New Label…	ラベル名…
+	New…	新規作成…
+	No sources yet.	資料文献はまだありません。
+	Numbering…	番号付け…
+	Options…	オプション…
+	Other	その他
+	Other styles and their TOC level:	その他のスタイルと目次レベル:
+	Outline levels	アウトライン レベル
+	Page number style	ページ番号のスタイル
+	Page numbers at the right margin	ページ番号を右端に配置
+	Page title	ページ名
+	Pages of bookmark:	ブックマークのページ:
+	Periodical	定期刊行物
+	Position:	位置:
+	Publisher	出版社
+	Run-in	追い込み
+	See	参照
+	Separator:	区切り文字:
+	Show every bibliography field	すべての文献フィールドを表示
+	Site name	サイト名
+	Source Manager	資料文献の管理
+	Source type:	資料文献の種類:
+	Sources in this document:	この文書の資料文献:
+	Styles:	スタイル:
+	Subentry:	副項目:
+	TC entry fields	TC 項目フィールド
+	Tab leader:	タブ リーダー:
+	Table of Contents Options	目次オプション
+	Table of Contents Styles	目次スタイル
+	This page	このページ
+	Type:	種類:
+	URL	URL
+	Volume	巻
+	Website	Web サイト
+	Year	年
+	a, b, c, …	a, b, c, …
+	i, ii, iii, …	i, ii, iii, …
+	{n} entries marked.	{n} 件の項目を登録しました。
+	Lasso Select	なげなわ選択
+	Move Selected Ink	選択したインクを移動
+	Delete Selected Ink	選択したインクを削除
+	Recolor Selected Ink	選択したインクの色を変更
+	Add Pen	ペンの追加
+	Remove Pen	ペンの削除
+	Ink to Shape	インクを図形に変換
+	Convert to Shapes	図形に変換
+	Ink Replay	インクの再生
+	Add\nPen	ペンの\n追加
+	Rewind	巻き戻し
+	Forward	早送り
+	Stroke {n} of {total}	ストローク {n}/{total}
+	Use wildcards	ワイルドカードを使う
+	Special	特殊文字
+	Match prefix	語頭が一致する
+	Match suffix	語尾が一致する
+	Ignore punctuation characters	句読点を無視する
+	Ignore white-space characters	空白文字を無視する
+	Regular expressions	正規表現
+	Search Options	検索オプション
+	Tab Character	タブ文字
+	Any Character	任意の 1 文字
+	Any Digit	任意の数字
+	Any Letter	任意の英字
+	Caret Character	キャレット記号
+	Section Character	セクション記号
+	Paragraph Character	段落記号文字
+	Graphic	図
+	Manual Line Break	手動の改行
+	Manual Page Break	手動の改ページ
+	Section Break	セクション区切り
+	White Space	空白
+	Clipboard Contents	クリップボードの内容
+	Find What Text	検索した文字列
+	Find What Expression	検索した式
+	Character in Range	範囲内の文字
+	Beginning of Word	単語の先頭
+	End of Word	単語の末尾
+	Expression	式
+	Not	否定
+	Num Occurrences	繰り返し回数
+	Previous 1 or More	直前の 1 回以上の繰り返し
+	0 or More Characters	0 文字以上の文字列
+	Move with Text	文字列と一緒に移動する
+	Fix Position on Page	ページ上で位置を固定する
+
+# WordArt and connectors (#416).
+	WordArt Styles	ワードアートのスタイル
+	Text Fill	文字の塗りつぶし
+	Text Outline	文字の輪郭
+	Transform	変形
+	No Fill	塗りつぶしなし
+	No Outline	輪郭なし
+	Reflection	反射
+	No Reflection	反射なし
+	No Transform	変形なし
+	Connect Shapes	図形をつなぐ
+	Straight Connector	直線コネクタ
+	Straight Arrow Connector	直線矢印コネクタ
+	Elbow Connector	カギ線コネクタ
+	Elbow Arrow Connector	カギ線矢印コネクタ
+	Curved Connector	曲線コネクタ
+	Curved Arrow Connector	曲線矢印コネクタ
+	Arch Up	上向きアーチ
+	Arch Down	下向きアーチ
+	Slant Up	右上がり
+	Slant Down	右下がり
+	Inflate	膨張
+	Deflate	収縮
+	Chevron Up	上向き山形
+	Chevron Down	下向き山形
+	Triangle Up	上向き三角形
+	Triangle Down	下向き三角形
+	Solid Accent	アクセントの単色
+	Light with Outline	明るい色と輪郭
+	Hollow	中抜き
+	Accent Gradient	アクセントのグラデーション
+	Dark with Shadow	暗い色と影
+	Soft Glow	柔らかい光彩
+	Accent with Reflection	アクセントと反射
+	Warm Gradient with Outline	暖色のグラデーションと輪郭
+	Add line numbering	行番号を追加する
+	Add to Document	文書に追加
+	Address labels	宛名ラベル
+	Arabic	アラビア語
+	Auto	自動
+	Automatically hyphenate document	文書を自動的にハイフネーションする
+	Chinese (Simplified)	中国語（簡体字）
+	Chinese (Traditional)	中国語（繁体字）
+	Column:	列:
+	Count by:	増分:
+	Czech	チェコ語
+	Danish	デンマーク語
+	Delivery address:	宛先:
+	Detect language automatically	言語を自動的に検出する
+	Do not check spelling or grammar	スペルチェックと文章校正を行わない
+	Dutch	オランダ語
+	Envelope size:	封筒サイズ:
+	Estonian	エストニア語
+	Finnish	フィンランド語
+	French (France)	フランス語（フランス）
+	From text:	本文からの距離:
+	Full page of the same label	同じラベルで 1 ページ全体
+	German (Germany)	ドイツ語（ドイツ）
+	Greek	ギリシャ語
+	Hebrew	ヘブライ語
+	Hyphenate at:	ハイフネーション位置:
+	Hyphenate words in CAPS	大文字の単語をハイフネーションする
+	Hyphenation Options…	ハイフネーションのオプション…
+	Hyphenation zone:	ハイフネーション領域:
+	Italian	イタリア語
+	Japanese	日本語
+	Korean	韓国語
+	Limit consecutive hyphens to:	連続するハイフンの上限:
+	Line Numbering Options…	行番号のオプション…
+	Manual Hyphenation	手動ハイフネーション
+	Manual hyphenation is complete.	手動ハイフネーションが完了しました。
+	Manual…	手動…
+	Mark selected text as:	選択した文字列の言語:
+	New Document	新規文書
+	No limit	制限なし
+	Norwegian (Bokmål)	ノルウェー語（ブークモール）
+	Numbering:	番号の付け方:
+	Omit	省略
+	One label per recipient	宛先ごとに 1 枚のラベル
+	Portuguese (Brazil)	ポルトガル語（ブラジル）
+	Portuguese (Portugal)	ポルトガル語（ポルトガル）
+	Return address labels	差出人ラベル
+	Return address:	差出人住所:
+	Row:	行:
+	Russian	ロシア語
+	Serbian (Cyrillic)	セルビア語（キリル文字）
+	Serbian (Latin)	セルビア語（ラテン文字）
+	Set As Default	既定に設定
+	Shipping labels	配送ラベル
+	Single label	1 枚のラベル
+	Spanish (Mexico)	スペイン語（メキシコ）
+	Spanish (Spain)	スペイン語（スペイン）
+	Swedish	スウェーデン語
+	Turkish	トルコ語
+	Ukrainian	ウクライナ語
+	{language} is now the document's default language.	{language} がこの文書の既定の言語になりました。
+	Visual effects	視覚効果
+	Animation effects:	アニメーション効果:
+	On	オン
+	Off	オフ
+	Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.	スクロールやズームのなめらかな動きと、メニューやボタンのフェード表示です。「オフ」にすると、すべての変化がすぐに表示されます。
+	Your system has animation effects turned on.	システムのアニメーション効果はオンです。
+	Your system has animation effects turned off.	システムのアニメーション効果はオフです。
+	Your system doesn't report an animation setting, so animation effects stay on.	システムからアニメーションの設定を取得できないため、アニメーション効果はオンのままです。
diff --git a/crates/ui-egui/src/i18n/mod.rs b/crates/ui-egui/src/i18n/mod.rs
index ae87c4fbe0..d0279a6f93 100644
--- a/crates/ui-egui/src/i18n/mod.rs
+++ b/crates/ui-egui/src/i18n/mod.rs
@@ -172,6 +172,14 @@ impl Lang {
         self.0.name.chars().any(|c| ('\u{2E80}'..='\u{9FFF}').contains(&c) || ('\u{AC00}'..='\u{D7AF}').contains(&c))
     }
 
+    /// The CJK interface text the fonts must cover with the Chinese (`hans`) or other CJK fallback
+    /// order: the catalogs of the CJK languages using that order, and every language's own name (the
+    /// Options list). The interface fonts check the embedded faces against it (#486).
+    pub fn cjk_font_text(hans: bool) -> (Vec<&'static str>, String) {
+        let catalogs = Lang::all().filter(|l| l.uses_cjk() && l.prefers_hans() == hans).map(|l| l.0.source).collect();
+        (catalogs, Lang::all().map(Lang::name).collect::<Vec<_>>().join(" "))
+    }
+
     /// A language by its exact code (any case).
     pub fn from_code(code: &str) -> Option<Lang> {
         LANGUAGES.iter().find(|l| l.code.eq_ignore_ascii_case(code)).map(Lang)
@@ -280,7 +288,7 @@ pub fn t(s: &str) -> &str {
     tr(current(), s)
 }
 
-/// `s` in the current language as worded for `context` (one of [`catalog::CONTEXTS`]), falling
+/// `s` in the current language as worded for `context` (one of `catalog::CONTEXTS`), falling
 /// back to the plain translation and then to English.
 pub fn tc<'a>(context: &str, s: &'a str) -> &'a str {
     trc(current(), context, s)
diff --git a/crates/ui-egui/src/i18n/pt-br.tsv b/crates/ui-egui/src/i18n/pt-br.tsv
index 2386498258..5c6a95f3f1 100644
--- a/crates/ui-egui/src/i18n/pt-br.tsv
+++ b/crates/ui-egui/src/i18n/pt-br.tsv
@@ -58,12 +58,15 @@
 	Arrange\nAll	Organizar\ntudo
 	Arrow	Seta
 	Artistic Effects	Efeitos artísticos
+	As you type	Enquanto você digita
+	Asian text font:	Fonte de texto asiático:
 	Asian Typography	Tipografia asiática
 	Author	Autor
 	AutoCorrect Options	Opções de autocorreção
 	AutoFit	Autoajuste
 	AutoFit Contents	Autoajustar ao conteúdo
 	AutoFit Window	Autoajustar à janela
+	AutoSave writes your changes to the file a moment after you stop typing.	O salvamento automático grava suas alterações no arquivo pouco depois que você para de digitar.
 	Automatic	Automático
 	Automatic ({language})	Automático ({language})
 	Automatic follows your system's language. Menus and commands change; your documents don't.	Automático segue o idioma do seu sistema. Menus e comandos mudam; seus documentos, não.
@@ -76,30 +79,67 @@
 	Balloons	Balões
 	Bullet	Marcador
 	By author	Por autor
+	Centimeters	Centímetros
 	Changed lines:	Linhas alteradas:
+	Check spelling as you type	Verificar a ortografia enquanto você digita
 	Click level to modify:	Clique no nível a modificar:
+	Click to switch back to inserting	Clique para voltar a inserir
 	Color only	Somente cor
+	Custom dictionary	Dicionário personalizado
 	Define New Multilevel List	Definir nova lista de vários níveis
 	Define New Multilevel List…	Definir nova lista de vários níveis…
 	Deletions:	Exclusões:
 	Enter formatting for number:	Formatação do número:
 	Follow number with:	Após o número:
 	Formatting	Formatação
+	Formatting marks	Marcas de formatação
+	Hidden text	Texto oculto
+	Ignore web and file addresses	Ignorar endereços da Web e de arquivos
+	Ignore words in capitals	Ignorar palavras em maiúsculas
+	Ignore words with numbers	Ignorar palavras com números
+	Inches	Polegadas
+	Formatting exceptions	Exceções de formatação
 	Include level number from:	Incluir número do nível:
+	Initials:	Iniciais:
 	Ink	Tinta
 	Insertions and Deletions	Inserções e exclusões
 	Insertions:	Inserções:
+	Interface	Interface
+	Interface language	Idioma da interface
+	Inside:	Interno:
+	Latin text font:	Fonte de texto latino:
 	Left border	Borda esquerda
 	Legal style numbering	Numeração no estilo legal
 	Link level to style:	Vincular nível ao estilo:
 	List Definition	Definição da lista
+	Mark grammar errors as you type	Marcar erros gramaticais enquanto você digita
+	Measurement units:	Unidades de medida:
+	Millimeters	Milímetros
+	New comments and tracked changes are recorded under this name and these initials.	Novos comentários e alterações controladas são registrados com este nome e estas iniciais.
+	New word	Nova palavra
+	No words yet. Add to Dictionary on a misspelled word puts it here.	Ainda não há palavras. Adicionar ao dicionário em uma palavra com erro a coloca aqui.
+	Mirror indents	Recuos espelhados
 	Nothing	Nada
 	Number alignment:	Alinhamento do número:
 	Number format	Formato do número
 	Number style for this level:	Estilo de número deste nível:
 	Outside border	Borda externa
+	Overtype	Sobrescrever
+	Overtype (typing replaces the characters after the caret)	Sobrescrever (o que você digita substitui os caracteres após o cursor)
+	Page display	Exibição da página
+	Paragraph marks	Marcas de parágrafo
+	Personalize	Personalizar
+	Picas	Paicas
+	Points	Pontos
+	Print the page color	Imprimir a cor da página
+	Printing	Impressão
+	Proofing language	Idioma de revisão
+	Recent documents to show:	Documentos recentes a mostrar:
+	Remove	Remover
+	Outside:	Externo:
 	Restart list after:	Reiniciar lista após:
 	Right border	Borda direita
+	Save documents	Salvar documentos
 	Save the document to turn on AutoSave	Salve o documento para ativar o salvamento automático
 	Save the document to turn on AutoSave (a file you have only opened isn't rewritten until you save it)	Salve o documento para ativar o salvamento automático (um arquivo que você apenas abriu não é regravado até você salvá-lo)
 	AutoText	Autotexto
@@ -122,6 +162,11 @@
 	Border Painter	Pincel de bordas
 	Border\nPainter	Pincel\nde bordas
 	Borders	Bordas
+	Show the mini toolbar when text is selected	Mostrar a minibarra de ferramentas ao selecionar texto
+	Spaces	Espaços
+	Spelling	Ortografia
+	Spelling and grammar are checked in English (United States).	A ortografia e a gramática são verificadas em inglês (Estados Unidos).
+	Tab characters	Caracteres de tabulação
 	Tab stop position:	Posição da tabulação:
 	Default tab stops:	Tabulações padrão:
 	Tab stops to be cleared:	Tabulações a remover:
@@ -132,6 +177,10 @@
 	Set	Definir
 	Page Border	Borda da página
 	Apply to:	Aplicar a:
+	These marks show even when Show/Hide ¶ is off.	Estas marcas aparecem mesmo com Mostrar/ocultar ¶ desativado.
+	Typing replaces selected text	O que você digita substitui o texto selecionado
+	Update fields before printing	Atualizar campos antes de imprimir
+	Use the Insert key to switch overtype on and off	Usar a tecla Insert para ativar e desativar a sobrescrita
 	Whole document	Documento inteiro
 	This section	Esta seção
 	Fill	Cor de fundo
@@ -270,7 +319,6 @@
 	Distribute spacing	Distribuir espaçamento
 	Offset (pt):	Deslocamento (pt):
 	Phonetic Guide	Guia fonético
-	Remove	Remover
 	Right (vertical)	Direita (vertical)
 	Ruby text:	Texto ruby:
 	Search for templates	Pesquisar modelos
@@ -333,6 +381,7 @@
 	Export PDF	Exportar PDF
 	Exported {path}	Exportado {path}
 	Extend Selection	Expandir seleção
+	Extend Selection by Units	Expandir seleção por unidades
 	Field	Campo
 	File	Arquivo
 	Find	Localizar
@@ -738,6 +787,9 @@
 	Show only comments and formatting in balloons	Mostrar apenas comentários e formatação em balões
 	Show revisions in balloons	Mostrar revisões em balões
 	Show rulers	Mostrar réguas
+	Animation	Animação
+	Animate the caret (it glides and fades)	Animar o ponto de inserção (desliza e esmaece)
+	On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off.	Ativado: o ponto de inserção desliza até a nova posição quando você digita ou usa as setas, e o piscar é suave. Desativado: ele salta e pisca de forma brusca.
 	Show the community button in the title bar	Mostrar o botão da comunidade na barra de título
 	Show/Hide ¶	Mostrar/ocultar ¶
 	Show\nComments	Mostrar\ncomentários
@@ -879,10 +931,10 @@
 	Wide	Ampla
 	Widow/Orphan Control	Controle de viúvas e órfãs
 	Widow/Orphan control	Controle de viúvas e órfãs
-	Wildcards (regex)	Curingas (regex)
 	Window	Janela
 	Word Count	Contagem de palavras
 	Word document (*.docx)	Documento Word (*.docx)
+	Word XML Document (*.xml)	Documento XML do Word (*.xml)
 	Word Left	Palavra à esquerda
 	Word Right	Palavra à direita
 	WordArt	Texto artístico
@@ -1360,8 +1412,86 @@
 	Selected Fields	Campos selecionados
 	Edit Field…	Editar campo…
 	Formatted	Formatado
+	Deleted	Excluído
 	Interface size:	Tamanho da interface:
 	Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate.	Aumenta ou diminui a faixa de opções, os menus e as caixas de diálogo, além da escala de exibição do sistema. O zoom do documento é separado.
+	Resize Table by Dragging	Redimensionar tabela arrastando
+	Print Markup	Imprimir marcação
+	Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text.	Comentários ao lado de cada página e alterações controladas em PDFs, impressões e imagens; uma lista de comentários no final de páginas da web, Markdown e texto.
+
+# Compare / Combine, AutoCorrect Options and Restrict Editing (#412)
+	1. Formatting restrictions	1. Restrições de formatação
+	2. Editing restrictions	2. Restrições de edição
+	3. Start enforcement	3. Aplicar a proteção
+	<< Less	<< Menos
+	Another file	Outro arquivo
+	Apply as you type	Aplicar ao digitar
+	AutoCorrect	Autocorreção
+	AutoFormat As You Type	AutoFormatação ao digitar
+	Automatic bulleted lists	Listas com marcadores automáticas
+	Automatic numbered lists	Listas numeradas automáticas
+	Border lines	Linhas de borda
+	Capitalize first letter of sentences	Primeira letra das frases em maiúscula
+	Capitalize first letter of table cells	Primeira letra das células em maiúscula
+	Capitalize names of days	Nomes dos dias em maiúscula
+	Case changes	Alterações de maiúsculas
+	Character level	Nível de caractere
+	Checked styles are allowed:	Os estilos marcados são permitidos:
+	Combine Documents	Combinar documentos
+	Compare Documents	Comparar documentos
+	Compared: {changes} changes	Comparado: {changes} alterações
+	Comparing with another file needs the desktop app.	Para comparar com outro arquivo é preciso o aplicativo para desktop.
+	Comparison settings	Configurações de comparação
+	Don't capitalize after:	Não colocar maiúscula depois de:
+	Editing in this document is restricted.	A edição deste documento está restrita.
+	Every change is recorded as a tracked change.	Cada alteração é registrada como alteração controlada.
+	Everyone	Todos
+	Exceptions (optional)	Exceções (opcional)
+	Exceptions…	Exceções…
+	Fields	Campos
+	Filling in forms	Preenchimento de formulários
+	Find Next Editable Region	Localizar a próxima região editável
+	Footnotes and endnotes	Notas de rodapé e notas de fim
+	Formatting, case changes, white space and tables are compared; the other settings are kept for later.	Formatação, maiúsculas, espaços em branco e tabelas são comparados; as outras configurações ficam para depois.
+	Fractions (1/2) as fraction characters (½)	Frações (1/2) como caracteres de fração (½)
+	Headers and footers	Cabeçalhos e rodapés
+	Hyphens (--) as dashes (—)	Hífens (--) como travessões (—)
+	In equations, typing a name after a backslash replaces it with its symbol.	Nas equações, digitar um nome após uma barra invertida o substitui pelo símbolo.
+	Internet addresses as links	Endereços da Internet como links
+	Label changes with:	Rotular alterações com:
+	Limit formatting to a selection of styles	Limitar a formatação a uma seleção de estilos
+	Math AutoCorrect	Autocorreção de matemática
+	More >>	Mais >>
+	Moves	Movimentações
+	New document	Novo documento
+	No changes (read only)	Sem alterações (somente leitura)
+	Only allow this kind of editing:	Permitir somente este tipo de edição:
+	Only comments can be added, except in regions marked editable.	Somente comentários podem ser adicionados, exceto nas regiões marcadas como editáveis.
+	Only form fields can be filled in.	Somente os campos de formulário podem ser preenchidos.
+	Only the allowed styles can be applied.	Somente os estilos permitidos podem ser aplicados.
+	Ordinals (1st) as superscript	Ordinais (1st) sobrescritos
+	Original document	Documento original
+	This password type isn't supported.	Este tipo de senha não é compatível.
+	Replace as you type	Substituir ao digitar
+	Replace text as you type	Substituir texto ao digitar
+	Replace:	Substituir:
+	Revised document	Documento revisado
+	Select text, then tick who can still edit it.	Selecione o texto e marque quem ainda pode editá-lo.
+	Settings…	Configurações…
+	Show changes at:	Mostrar alterações no nível de:
+	Show changes in:	Mostrar alterações em:
+	Smart quotes instead of straight quotes	Aspas inteligentes em vez de retas
+	Start Enforcing Protection	Aplicar a proteção
+	Stop Protection	Parar proteção
+	Text boxes	Caixas de texto
+	The document is read only, except for regions marked editable.	O documento é somente leitura, exceto nas regiões marcadas como editáveis.
+	The password is optional; without it anyone can stop the protection.	A senha é opcional; sem ela, qualquer pessoa pode parar a proteção.
+	This document	Este documento
+	Tracked changes	Alterações controladas
+	Type the password to stop the protection.	Digite a senha para parar a proteção.
+	White space	Espaços em branco
+	With:	Por:
+	Word level	Nível de palavra
 	In Line with Text	Alinhado ao texto
 	Square	Quadrado
 	Through	Através
@@ -1408,6 +1538,36 @@
 	New Group	Novo Grupo
 	Rename…	Renomear…
 	Ribbon and Quick Access Toolbar:	Faixa de Opções e Barra de Acesso Rápido:
+	Add Font…	Adicionar fonte…
+	Added Fonts	Fontes adicionadas
+	Remove Added Font	Remover fonte adicionada
+	Recent Colors	Cores recentes
+	More Colors…	Mais cores…
+	Standard	Padrão
+	Current	Atual
+	Colors:	Cores:
+	Color model:	Modelo de cor:
+	Red:	Vermelho:
+	Green:	Verde:
+	Blue:	Azul:
+	Hue:	Matiz:
+	Sat:	Sat.:
+	Lum:	Lum.:
+	Hex:	Hex.:
+	Accessibility Pane	Painel de acessibilidade
+	Alt Text Pane	Painel de texto alternativo
+	Alt\nText	Texto\nalternativo
+	View Alt Text…	Exibir texto alternativo…
+	Mark as decorative	Marcar como decorativo
+	Title:	Título:
+	Errors ({n})	Erros ({n})
+	Warnings ({n})	Avisos ({n})
+	Tips ({n})	Dicas ({n})
+	No accessibility issues found.	Nenhum problema de acessibilidade encontrado.
+	Describe what this object shows, for people who can't see it.	Descreva o que este objeto mostra, para quem não pode vê-lo.
+	Decorative objects only add visual interest: screen readers skip them.	Objetos decorativos só acrescentam interesse visual: os leitores de tela os ignoram.
+	Describe what this table shows, for people who can't see it.	Descreva o que esta tabela mostra, para quem não pode vê-la.
+	Select a picture, shape, chart or table to describe it.	Selecione uma imagem, forma, gráfico ou tabela para descrevê-lo.
 	Document Grid	Grade do documento
 	No grid	Sem grade
 	Lines only	Somente linhas
@@ -1417,6 +1577,39 @@
 	Lines per page:	Linhas por página:
 	Moved from	Movido de
 	Moved to	Movido para
+	Developer	Desenvolvedor
+	Controls	Controles
+	Rich Text Content Control	Controle de conteúdo de rich text
+	Plain Text Content Control	Controle de conteúdo de texto sem formatação
+	Picture Content Control	Controle de conteúdo de imagem
+	Building Block Gallery Content Control	Controle de conteúdo da galeria de blocos de construção
+	Check Box Content Control	Controle de conteúdo de caixa de seleção
+	Combo Box Content Control	Controle de conteúdo de caixa de combinação
+	Drop-Down List Content Control	Controle de conteúdo de lista suspensa
+	Date Picker Content Control	Controle de conteúdo de seletor de data
+	Repeating Section Content Control	Controle de conteúdo de seção repetida
+	Design Mode	Modo de Design
+	Content Control at Selection	Controle de conteúdo na seleção
+	Toggle Check Box	Alternar caixa de seleção
+	Choose List Item	Escolher item da lista
+	Set Date	Definir data
+	Remove Content Control	Remover controle de conteúdo
+	Content Control Properties	Propriedades do controle de conteúdo
+	Title	Título
+	Tag	Marca
+	Placeholder text	Texto do espaço reservado
+	Can't be deleted	Não pode ser excluído
+	Contents can't be edited	O conteúdo não pode ser editado
+	Remove the control once edited	Remover o controle após a edição
+	Allow line breaks	Permitir quebras de linha
+	Date format	Formato da data
+	Checked symbol	Símbolo marcado
+	Unchecked symbol	Símbolo desmarcado
+	List entries	Itens da lista
+	Display text	Texto exibido
+	Value	Valor
+	Today	Hoje
+	Put the caret in a content control first.	Coloque primeiro o cursor em um controle de conteúdo.
 	Right-to-Left Table	Tabela da direita para a esquerda
 	Right-to-Left Section	Seção da direita para a esquerda
 	Table direction:	Direção da tabela:
@@ -1444,6 +1637,50 @@
 	Enlarge symbol	Ampliar símbolo
 	Enclosure	Contorno
 	Circle	Círculo
+	Templates	Modelos
+	Templates and Add-ins	Modelos e suplementos
+	Attach Template	Anexar modelo
+	Detach Template	Desanexar modelo
+	Automatically Update Document Styles	Atualizar automaticamente os estilos do documento
+	Update Styles from Template	Atualizar estilos a partir do modelo
+	Organizer	Organizador
+	Copy Styles	Copiar estilos
+	Rename Style	Renomear estilo
+	Document template:	Modelo do documento:
+	Attach…	Anexar…
+	Automatically update document styles	Atualizar automaticamente os estilos do documento
+	Organizer…	Organizador…
+	Change Chart Type	Alterar tipo de gráfico
+	Chart Design	Design do gráfico
+	Type	Tipo
+	Edit Data	Editar dados
+	Chart Title	Título do gráfico
+	Chart Layouts	Layouts do gráfico
+	Add Chart Element	Adicionar elemento ao gráfico
+	Legend	Legenda
+	Data Labels	Rótulos de dados
+	Above Chart	Acima do gráfico
+	Insert Chart	Inserir gráfico
+	Clustered Column	Colunas agrupadas
+	Stacked Column	Colunas empilhadas
+	Clustered Bar	Barras agrupadas
+	Stacked Bar	Barras empilhadas
+	Area	Área
+	Pie	Pizza
+	Doughnut	Rosca
+	Scatter	Dispersão
+	“{text}” ({row}, {series}) isn't a number.	“{text}” ({row}, {series}) não é um número.
+	Category {n}	Categoria {n}
+	Series {n}	Série {n}
+	Type the categories down the side and a column of values per series.	Digite as categorias na lateral e uma coluna de valores por série.
+	Categories	Categorias
+	Series name	Nome da série
+	Remove series	Remover série
+	Remove row	Remover linha
+	Add Row	Adicionar linha
+	Add Series	Adicionar série
+	Edit\nData	Editar\ndados
+	Change\nChart Type	Alterar tipo\nde gráfico
 	Align Text	Alinhar texto
 	Create Link	Criar link
 	Break Link	Quebrar link
@@ -1468,3 +1705,346 @@
 	English (United Kingdom)	Inglês (Reino Unido)
 	Polish	Polonês
 	Do Not Check Spelling or Grammar	Não verificar ortografia nem gramática
+
+# Built-in file browser when the system file dialog is unavailable (#576)
+	Documents	Documentos
+	Word document	Documento do Word
+	All files	Todos os arquivos
+	Recipient lists	Listas de destinatários
+	The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity.	A caixa de diálogo de arquivos do sistema não está disponível, então o WordCraft mostra a sua própria. Para usar a do sistema, instale um portal seletor de arquivos (como xdg-desktop-portal-gtk) ou o zenity.
+	Up one level	Subir um nível
+	Home folder	Pasta pessoal
+	{name} wasn't found.	{name} não foi encontrado.
+	{name} already exists. Choose Save again to replace it.	{name} já existe. Escolha Salvar novamente para substituí-lo.
+	This folder can't be read: {error}	Não é possível ler esta pasta: {error}
+	Showing the first {count} items.	Mostrando os primeiros {count} itens.
+	File name:	Nome do arquivo:
+	Browse in WordCraft…	Procurar no WordCraft…
+	Open a file with WordCraft's own browser when the system file dialog doesn't appear.	Abra um arquivo com o navegador próprio do WordCraft quando a caixa de diálogo de arquivos do sistema não aparecer.
+	Hide White Space	Ocultar espaço em branco
+	All pages	Todas as páginas
+	Current page	Página atual
+	Selected pages	Páginas selecionadas
+	Custom range	Intervalo personalizado
+	All pages in the range	Todas as páginas do intervalo
+	Odd pages only	Somente páginas ímpares
+	Even pages only	Somente páginas pares
+	Copies	Cópias
+	Collate copies	Agrupar cópias
+	Pages like 1-3, 5	Páginas como 1-3, 5
+	{count} of {total} pages will print	{count} de {total} páginas serão impressas
+	Save these pages as PDF…	Salvar estas páginas como PDF…
+	The printer, two-sided printing and pages per sheet are chosen in that dialog.	A impressora, a impressão frente e verso e as páginas por folha são escolhidas nessa caixa de diálogo.
+	Previous Page	Página anterior
+	Print to PDF	Imprimir em PDF
+	Add Shape	Adicionar forma
+	Change Colors	Alterar cores
+	Change Layout	Alterar layout
+	Create Graphic	Criar gráfico
+	Edit Items	Editar itens
+	Layouts	Layouts
+	Reset Graphic	Redefinir gráfico
+	SmartArt Design	Design do SmartArt
+	SmartArt Styles	Estilos de SmartArt
+	Text Pane	Painel de texto
+	List	Lista
+	Process	Processo
+	Cycle	Ciclo
+	Hierarchy	Hierarquia
+	Relationship	Relação
+	Pyramid	Pirâmide
+	Basic List	Lista básica
+	Basic Process	Processo básico
+	Basic Cycle	Ciclo básico
+	Basic Pyramid	Pirâmide básica
+	Basic Radial	Radial básico
+	Basic Matrix	Matriz básica
+	Basic Venn	Venn básico
+	Shows items of equal weight as blocks in rows.	Mostra itens de mesmo peso como blocos em linhas.
+	Shows steps in order, left to right, with arrows between them.	Mostra etapas em ordem, da esquerda para a direita, com setas entre elas.
+	Shows steps that repeat, around a circle.	Mostra etapas que se repetem, ao redor de um círculo.
+	Shows a tree: each item below the item it belongs to.	Mostra uma árvore: cada item abaixo do item ao qual pertence.
+	Shows parts that build on each other, largest at the bottom.	Mostra partes que se apoiam umas nas outras, a maior embaixo.
+	Shows items around a central idea: the first item is the centre.	Mostra itens ao redor de uma ideia central: o primeiro item é o centro.
+	Shows parts of a whole as quadrants.	Mostra as partes de um todo como quadrantes.
+	Shows overlapping ideas as overlapping circles.	Mostra ideias sobrepostas como círculos sobrepostos.
+	Accent {n}	Ênfase {n}
+	Colorful	Colorido
+	Insert SmartArt	Inserir SmartArt
+	One line per item. Enter adds an item.	Uma linha por item. Enter adiciona um item.
+	Add\nShape	Adicionar\nforma
+	Change\nColors	Alterar\ncores
+	Reset\nGraphic	Redefinir\ngráfico
+	Promote to Heading 1	Promover a Título 1
+	Demote to Body Text	Rebaixar a corpo do texto
+	Move Up	Mover para cima
+	Move Down	Mover para baixo
+	Collapse	Recolher
+	Expand or Collapse Heading	Expandir ou recolher título
+	Select Heading and Content	Selecionar título e conteúdo
+	Show Level	Mostrar nível
+	Show Level 1	Mostrar nível 1
+	Show Level 2	Mostrar nível 2
+	Show Level 3	Mostrar nível 3
+	Show Level 4	Mostrar nível 4
+	Show Level 5	Mostrar nível 5
+	Show Level 6	Mostrar nível 6
+	Show Level 7	Mostrar nível 7
+	Show Level 8	Mostrar nível 8
+	Show Level 9	Mostrar nível 9
+	Show All Levels	Mostrar todos os níveis
+	All Levels	Todos os níveis
+	Show First Line Only	Mostrar só a primeira linha
+	Show Text Formatting	Mostrar formatação do texto
+	Close Outline View	Fechar estrutura de tópicos
+	Outline State	Estado da estrutura de tópicos
+	Outlining	Estrutura de tópicos
+	Outline Tools	Ferramentas de tópicos
+	Close Outline\nView	Fechar estrutura\nde tópicos
+	A, B, C, …	A, B, C, …
+	Above the item	Acima do item
+	Accessed on	Acessado em
+	Add New Source…	Adicionar nova fonte…
+	Add the chapter number	Adicionar o número do capítulo
+	Atmosphere	Atmosfera
+	Below the item	Abaixo do item
+	Book	Livro
+	Book title	Título do livro
+	Caption	Legenda
+	Caption Numbering	Numeração de legendas
+	Caption text	Texto da legenda
+	Caption:	Legenda:
+	Chapter in a book	Capítulo de livro
+	Chapters begin at:	Os capítulos começam em:
+	Collect entries from:	Coletar entradas de:
+	Columns:	Colunas:
+	Conference	Conferência
+	Conference paper	Artigo de conferência
+	Container Title	Título do contêiner
+	Create Source	Criar fonte
+	Cross-reference:	Referência cruzada:
+	Custom Table of Contents…	Sumário personalizado…
+	DOI	DOI
+	Day	Dia
+	Delete Label	Excluir rótulo
+	Edit Source	Editar fonte
+	Edition	Edição
+	Edit…	Editar…
+	Entry marked.	Entrada marcada.
+	Example: {sample}	Exemplo: {sample}
+	Figure	Figura
+	Film	Filme
+	Heading styles (levels 1–{n})	Estilos de título (níveis 1–{n})
+	Heading {n}	Título {n}
+	I, II, III, …	I, II, III, …
+	Include page numbers	Incluir números de página
+	Indented	Recuado
+	Institution	Instituição
+	Ionosphere	Ionosfera
+	Issue	Número
+	Journal	Periódico científico
+	Label:	Rótulo:
+	Last, First; Last, First	Sobrenome, Nome; Sobrenome, Nome
+	Leave the label out of the caption	Omitir o rótulo na legenda
+	Letter headings	Cabeçalhos de letra
+	Levels:	Níveis:
+	Link entries to their headings	Vincular as entradas aos títulos
+	Made from the author and year when empty	Se vazio, é formado pelo autor e ano
+	Magazine or newspaper article	Artigo de revista ou jornal
+	Main entry:	Entrada principal:
+	Mark	Marcar
+	Mark All	Marcar todas
+	Mark Entry…	Marcar entrada…
+	Mark Index Entry	Marcar entrada de índice
+	Mesosphere	Mesosfera
+	Month	Mês
+	New Label	Novo rótulo
+	New Label…	Novo rótulo…
+	New…	Nova…
+	No sources yet.	Ainda não há fontes.
+	Numbering…	Numeração…
+	Options…	Opções…
+	Other	Outro
+	Other styles and their TOC level:	Outros estilos e seu nível no sumário:
+	Outline levels	Níveis de estrutura de tópicos
+	Page number style	Estilo do número de página
+	Page numbers at the right margin	Números de página na margem direita
+	Page title	Título da página
+	Pages of bookmark:	Páginas do indicador:
+	Periodical	Periódico
+	Position:	Posição:
+	Publisher	Editora
+	Run-in	Contínuo
+	See	Ver
+	Separator:	Separador:
+	Show every bibliography field	Mostrar todos os campos bibliográficos
+	Site name	Nome do site
+	Source Manager	Gerenciador de fontes
+	Source type:	Tipo de fonte:
+	Sources in this document:	Fontes deste documento:
+	Styles:	Estilos:
+	Subentry:	Subentrada:
+	TC entry fields	Campos de entrada TC
+	Tab leader:	Preenchimento de tabulação:
+	Table of Contents Options	Opções do sumário
+	Table of Contents Styles	Estilos do sumário
+	This page	Esta página
+	Type:	Tipo:
+	URL	URL
+	Volume	Volume
+	Website	Site
+	Year	Ano
+	a, b, c, …	a, b, c, …
+	i, ii, iii, …	i, ii, iii, …
+	{n} entries marked.	Entradas marcadas: {n}.
+	Lasso Select	Seleção com laço
+	Move Selected Ink	Mover a tinta selecionada
+	Delete Selected Ink	Excluir a tinta selecionada
+	Recolor Selected Ink	Mudar a cor da tinta selecionada
+	Add Pen	Adicionar caneta
+	Remove Pen	Remover caneta
+	Ink to Shape	Tinta para forma
+	Convert to Shapes	Converter em formas
+	Ink Replay	Reproduzir tinta
+	Add\nPen	Adicionar\ncaneta
+	Rewind	Retroceder
+	Forward	Avançar
+	Stroke {n} of {total}	Traço {n} de {total}
+	Use wildcards	Usar caracteres curinga
+	Special	Especial
+	Match prefix	Coincidir prefixo
+	Match suffix	Coincidir sufixo
+	Ignore punctuation characters	Ignorar sinais de pontuação
+	Ignore white-space characters	Ignorar espaços em branco
+	Regular expressions	Expressões regulares
+	Search Options	Opções de pesquisa
+	Tab Character	Caractere de tabulação
+	Any Character	Qualquer caractere
+	Any Digit	Qualquer dígito
+	Any Letter	Qualquer letra
+	Caret Character	Acento circunflexo
+	Section Character	Símbolo de seção
+	Paragraph Character	Símbolo de parágrafo
+	Graphic	Gráfico
+	Manual Line Break	Quebra de linha manual
+	Manual Page Break	Quebra de página manual
+	Section Break	Quebra de seção
+	White Space	Espaço em branco
+	Clipboard Contents	Conteúdo da área de transferência
+	Find What Text	Texto localizado
+	Find What Expression	Expressão localizada
+	Character in Range	Caractere no intervalo
+	Beginning of Word	Início da palavra
+	End of Word	Fim da palavra
+	Expression	Expressão
+	Not	Não
+	Num Occurrences	Número de ocorrências
+	Previous 1 or More	Anterior 1 ou mais vezes
+	0 or More Characters	0 ou mais caracteres
+	Move with Text	Mover com o texto
+	Fix Position on Page	Fixar posição na página
+
+# WordArt and connectors (#416).
+	WordArt Styles	Estilos de WordArt
+	Text Fill	Preenchimento do texto
+	Text Outline	Contorno do texto
+	Transform	Transformar
+	No Fill	Sem preenchimento
+	No Outline	Sem contorno
+	Reflection	Reflexo
+	No Reflection	Sem reflexo
+	No Transform	Sem transformação
+	Connect Shapes	Conectar formas
+	Straight Connector	Conector reto
+	Straight Arrow Connector	Conector reto com seta
+	Elbow Connector	Conector angular
+	Elbow Arrow Connector	Conector angular com seta
+	Curved Connector	Conector curvo
+	Curved Arrow Connector	Conector curvo com seta
+	Arch Up	Arco para cima
+	Arch Down	Arco para baixo
+	Slant Up	Inclinação para cima
+	Slant Down	Inclinação para baixo
+	Inflate	Inflar
+	Deflate	Desinflar
+	Chevron Up	Divisa para cima
+	Chevron Down	Divisa para baixo
+	Triangle Up	Triângulo para cima
+	Triangle Down	Triângulo para baixo
+	Solid Accent	Destaque sólido
+	Light with Outline	Claro com contorno
+	Hollow	Vazado
+	Accent Gradient	Gradiente de destaque
+	Dark with Shadow	Escuro com sombra
+	Soft Glow	Brilho suave
+	Accent with Reflection	Destaque com reflexo
+	Warm Gradient with Outline	Gradiente quente com contorno
+	Add line numbering	Adicionar numeração de linhas
+	Add to Document	Adicionar ao documento
+	Address labels	Etiquetas de endereço
+	Arabic	Árabe
+	Auto	Auto
+	Automatically hyphenate document	Hifenizar o documento automaticamente
+	Chinese (Simplified)	Chinês (simplificado)
+	Chinese (Traditional)	Chinês (tradicional)
+	Column:	Coluna:
+	Count by:	Intervalo:
+	Czech	Tcheco
+	Danish	Dinamarquês
+	Delivery address:	Endereço de entrega:
+	Detect language automatically	Detectar o idioma automaticamente
+	Do not check spelling or grammar	Não verificar ortografia nem gramática
+	Dutch	Holandês
+	Envelope size:	Tamanho do envelope:
+	Estonian	Estoniano
+	Finnish	Finlandês
+	French (France)	Francês (França)
+	From text:	Distância do texto:
+	Full page of the same label	Página inteira da mesma etiqueta
+	German (Germany)	Alemão (Alemanha)
+	Greek	Grego
+	Hebrew	Hebraico
+	Hyphenate at:	Hifenizar em:
+	Hyphenate words in CAPS	Hifenizar palavras em MAIÚSCULAS
+	Hyphenation Options…	Opções de hifenização…
+	Hyphenation zone:	Zona de hifenização:
+	Italian	Italiano
+	Japanese	Japonês
+	Korean	Coreano
+	Limit consecutive hyphens to:	Limitar hífens consecutivos a:
+	Line Numbering Options…	Opções de numeração de linhas…
+	Manual Hyphenation	Hifenização manual
+	Manual hyphenation is complete.	A hifenização manual foi concluída.
+	Manual…	Manual…
+	Mark selected text as:	Marcar o texto selecionado como:
+	New Document	Novo documento
+	No limit	Sem limite
+	Norwegian (Bokmål)	Norueguês (bokmål)
+	Numbering:	Numeração:
+	Omit	Omitir
+	One label per recipient	Uma etiqueta por destinatário
+	Portuguese (Brazil)	Português (Brasil)
+	Portuguese (Portugal)	Português (Portugal)
+	Return address labels	Etiquetas de remetente
+	Return address:	Endereço do remetente:
+	Row:	Linha:
+	Russian	Russo
+	Serbian (Cyrillic)	Sérvio (cirílico)
+	Serbian (Latin)	Sérvio (latino)
+	Set As Default	Definir como padrão
+	Shipping labels	Etiquetas de envio
+	Single label	Etiqueta única
+	Spanish (Mexico)	Espanhol (México)
+	Spanish (Spain)	Espanhol (Espanha)
+	Swedish	Sueco
+	Turkish	Turco
+	Ukrainian	Ucraniano
+	{language} is now the document's default language.	{language} agora é o idioma padrão do documento.
+	Visual effects	Efeitos visuais
+	Animation effects:	Efeitos de animação:
+	On	Ativado
+	Off	Desativado
+	Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.	Rolagem e zoom suaves, e menus e botões que aparecem gradualmente. Com “Desativado”, cada alteração é mostrada de imediato.
+	Your system has animation effects turned on.	Seu sistema está com os efeitos de animação ativados.
+	Your system has animation effects turned off.	Seu sistema está com os efeitos de animação desativados.
+	Your system doesn't report an animation setting, so animation effects stay on.	Seu sistema não informa uma configuração de animação, então os efeitos de animação continuam ativados.
diff --git a/crates/ui-egui/src/i18n/ru.tsv b/crates/ui-egui/src/i18n/ru.tsv
index f9c78f39ab..e8649be82a 100644
--- a/crates/ui-egui/src/i18n/ru.tsv
+++ b/crates/ui-egui/src/i18n/ru.tsv
@@ -253,6 +253,7 @@
 	Export PDF	Экспорт в PDF
 	Exported {path}	Экспортировано: {path}
 	Extend Selection	Расширить выделение
+	Extend Selection by Units	Расширить выделение по единицам
 	Field	Поле
 	File	Файл
 	Find	Найти
@@ -659,6 +660,9 @@
 	Show Markup	Показать исправления
 	Show Notes	Показать сноски
 	Show rulers	Показывать линейки
+	Animate the caret (it glides and fades)	Анимировать курсор (плавно перемещается и угасает)
+	Animation	Анимация
+	On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off.	Вкл.: при вводе текста и нажатии клавиш со стрелками курсор плавно перемещается на новое место, а его мигание плавно угасает. Выкл.: курсор перескакивает и резко мигает.
 	Show the community button in the title bar	Показывать кнопку сообщества в заголовке окна
 	Show/Hide ¶	Показать/скрыть ¶
 	Show\nComments	Показать\nкомментарии
@@ -804,7 +808,6 @@ preview	Title	Пример
 	Wide	Широкие
 	Widow/Orphan Control	Запрет висячих строк
 	Widow/Orphan control	Запрет висячих строк
-	Wildcards (regex)	Подстановочные знаки (regex)
 	Window	Окно
 	Word Count	Число слов
 	Word document (*.docx)	Документ Word (*.docx)
@@ -1706,6 +1709,7 @@ preview	Title	Пример
 	Centered as Group	По центру как группа
 	✓ None	✓ Нет
 	Formatted	Отформатировано
+	Deleted	Удалено
 	Interface size:	Размер интерфейса:
 	Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate.	Увеличивает или уменьшает ленту, меню и диалоговые окна поверх системного масштабирования экрана. Масштаб документа настраивается отдельно.
 	Copyright Sign	Знак авторского права
@@ -1790,6 +1794,39 @@ preview	Title	Пример
 	Left Only	Только слева
 	Right Only	Только справа
 	Largest Only	Только по большей стороне
+	Resize Table by Dragging	Изменение размера таблицы перетаскиванием
+	Add Font…	Добавить шрифт…
+	Added Fonts	Добавленные шрифты
+	Remove Added Font	Удалить добавленный шрифт
+	Print Markup	Печатать исправления и примечания
+	Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text.	Примечания рядом с каждой страницей и отслеживаемые изменения в PDF, при печати и в изображениях; список примечаний в конце веб-страниц, Markdown и текста.
+	Recent Colors	Последние цвета
+	More Colors…	Другие цвета…
+	Standard	Обычные
+	Current	Текущий
+	Colors:	Цвета:
+	Color model:	Цветовая модель:
+	Red:	Красный:
+	Green:	Зеленый:
+	Blue:	Синий:
+	Hue:	Оттенок:
+	Sat:	Насыщенность:
+	Lum:	Яркость:
+	Hex:	Hex:
+	Accessibility Pane	Область специальных возможностей
+	Alt Text Pane	Область замещающего текста
+	Alt\nText	Замещающий\nтекст
+	View Alt Text…	Показать замещающий текст…
+	Mark as decorative	Пометить как декоративный
+	Title:	Заголовок:
+	Errors ({n})	Ошибки ({n})
+	Warnings ({n})	Предупреждения ({n})
+	Tips ({n})	Советы ({n})
+	No accessibility issues found.	Проблем со специальными возможностями не найдено.
+	Describe what this object shows, for people who can't see it.	Опишите, что показывает этот объект, для людей, которые его не видят.
+	Decorative objects only add visual interest: screen readers skip them.	Декоративные объекты лишь украшают документ: программы чтения с экрана их пропускают.
+	Describe what this table shows, for people who can't see it.	Опишите, что показывает эта таблица, для людей, которые её не видят.
+	Select a picture, shape, chart or table to describe it.	Выберите рисунок, фигуру, диаграмму или таблицу, чтобы описать её.
 	Document Grid	Сетка документа
 	No grid	Без сетки
 	Lines only	Только строки
@@ -1799,10 +1836,149 @@ preview	Title	Пример
 	Lines per page:	Строк на странице:
 	Moved from	Перемещено из
 	Moved to	Перемещено в
+	Developer	Разработчик
+	Controls	Элементы управления
+	Rich Text Content Control	Элемент управления содержимым: форматированный текст
+	Plain Text Content Control	Элемент управления содержимым: обычный текст
+	Picture Content Control	Элемент управления содержимым: рисунок
+	Building Block Gallery Content Control	Элемент управления содержимым: коллекция стандартных блоков
+	Check Box Content Control	Элемент управления содержимым: флажок
+	Combo Box Content Control	Элемент управления содержимым: поле со списком
+	Drop-Down List Content Control	Элемент управления содержимым: раскрывающийся список
+	Date Picker Content Control	Элемент управления содержимым: выбор даты
+	Repeating Section Content Control	Элемент управления содержимым: повторяющийся раздел
+	Design Mode	Режим конструктора
+	Content Control at Selection	Элемент управления содержимым в выделении
+	Toggle Check Box	Переключить флажок
+	Choose List Item	Выбрать элемент списка
+	Set Date	Задать дату
+	Remove Content Control	Удалить элемент управления содержимым
+	Content Control Properties	Свойства элемента управления содержимым
+	Tag	Тег
+	Placeholder text	Текст-заполнитель
+	Can't be deleted	Нельзя удалять
+	Contents can't be edited	Содержимое нельзя изменять
+	Remove the control once edited	Удалить элемент управления после редактирования
+	Allow line breaks	Разрешить разрывы строк
+	Date format	Формат даты
+	Checked symbol	Символ установленного флажка
+	Unchecked symbol	Символ снятого флажка
+	List entries	Элементы списка
+	Display text	Отображаемый текст
+	Value	Значение
+	Today	Сегодня
+	Put the caret in a content control first.	Сначала поместите курсор в элемент управления содержимым.
 	Right-to-Left Table	Таблица справа налево
 	Right-to-Left Section	Раздел справа налево
 	Table direction:	Направление таблицы:
 	Section direction:	Направление раздела:
+	A, B, C, …	A, B, C, …
+	Above the item	Над объектом
+	Accessed on	Дата обращения
+	Add New Source…	Добавить новый источник…
+	Add the chapter number	Добавить номер главы
+	Atmosphere	Атмосфера
+	Below the item	Под объектом
+	Book	Книга
+	Book title	Название книги
+	Caption Numbering	Нумерация названий
+	Caption text	Текст названия
+	Caption:	Название:
+	Chapter in a book	Глава книги
+	Chapters begin at:	Главы начинаются с:
+	Collect entries from:	Собирать записи из:
+	Columns:	Столбцы:
+	Conference	Конференция
+	Conference paper	Доклад на конференции
+	Container Title	Название контейнера
+	Create Source	Создать источник
+	Cross-reference:	Перекрёстная ссылка:
+	Custom Table of Contents…	Настраиваемое оглавление…
+	DOI	DOI
+	Day	День
+	Delete Label	Удалить подпись
+	Edit Source	Изменить источник
+	Edition	Издание
+	Edit…	Изменить…
+	Entry marked.	Запись помечена.
+	Example: {sample}	Пример: {sample}
+	Figure	Рисунок
+	Film	Фильм
+	Heading styles (levels 1–{n})	Стили заголовков (уровни 1–{n})
+	I, II, III, …	I, II, III, …
+	Include page numbers	Включить номера страниц
+	Indented	Со ступенчатым отступом
+	Institution	Учреждение
+	Ionosphere	Ионосфера
+	Issue	Выпуск
+	Journal	Журнал
+	Label:	Подпись:
+	Last, First; Last, First	Фамилия, Имя; Фамилия, Имя
+	Leave the label out of the caption	Не включать подпись в название
+	Letter headings	Заголовки с буквами
+	Levels:	Уровни:
+	Link entries to their headings	Связать записи с заголовками
+	Made from the author and year when empty	Если пусто, составляется из автора и года
+	Magazine or newspaper article	Статья в журнале или газете
+	Main entry:	Основная запись:
+	Mark	Пометить
+	Mark All	Пометить все
+	Mark Entry…	Пометить запись…
+	Mark Index Entry	Пометка элемента указателя
+	Mesosphere	Мезосфера
+	Month	Месяц
+	New Label	Новая подпись
+	New Label…	Новая подпись…
+	New…	Создать…
+	No sources yet.	Источников пока нет.
+	Numbering…	Нумерация…
+	Options…	Параметры…
+	Other	Другое
+	Other styles and their TOC level:	Другие стили и их уровень в оглавлении:
+	Outline levels	Уровни структуры
+	Page number style	Стиль номеров страниц
+	Page numbers at the right margin	Номера страниц по правому краю
+	Page title	Название страницы
+	Pages of bookmark:	Страницы закладки:
+	Periodical	Периодическое издание
+	Position:	Положение:
+	Publisher	Издатель
+	Run-in	В подбор
+	See	См.
+	Separator:	Разделитель:
+	Show every bibliography field	Показать все поля библиографии
+	Site name	Название сайта
+	Source Manager	Диспетчер источников
+	Source type:	Тип источника:
+	Sources in this document:	Источники в этом документе:
+	Styles:	Стили:
+	Subentry:	Подзапись:
+	TC entry fields	Поля записей TC
+	Tab leader:	Заполнитель табуляции:
+	Table of Contents Options	Параметры оглавления
+	Table of Contents Styles	Стили оглавления
+	This page	Эта страница
+	Type:	Тип:
+	URL	URL
+	Volume	Том
+	Website	Веб-сайт
+	Year	Год
+	a, b, c, …	a, b, c, …
+	i, ii, iii, …	i, ii, iii, …
+	{n} entries marked.	Помечено записей: {n}.
+	Lasso Select	Лассо
+	Move Selected Ink	Переместить выделенные штрихи
+	Delete Selected Ink	Удалить выделенные штрихи
+	Recolor Selected Ink	Перекрасить выделенные штрихи
+	Add Pen	Добавить перо
+	Remove Pen	Удалить перо
+	Ink to Shape	Рукописный ввод в фигуры
+	Convert to Shapes	Преобразовать в фигуры
+	Ink Replay	Воспроизведение рукописного ввода
+	Add\nPen	Добавить\nперо
+	Rewind	Назад
+	Forward	Вперёд
+	Stroke {n} of {total}	Штрих {n} из {total}
 	Drawing Canvas	Полотно для рисования
 	New Drawing Canvas	Новое полотно для рисования
 	Fit	По размеру
@@ -1822,6 +1998,122 @@ preview	Title	Пример
 	Search icons	Поиск значков
 	No icons match your search.	Нет значков, соответствующих поиску.
 	Recolor a one-color picture, such as an icon	Перекрасить одноцветный рисунок, например значок
+	Templates	Шаблоны
+	Templates and Add-ins	Шаблоны и надстройки
+	Attach Template	Присоединить шаблон
+	Detach Template	Отсоединить шаблон
+	Automatically Update Document Styles	Автоматически обновлять стили документа
+	Update Styles from Template	Обновить стили из шаблона
+	Organizer	Организатор
+	Copy Styles	Копировать стили
+	Rename Style	Переименовать стиль
+	Document template:	Шаблон документа:
+	Attach…	Присоединить…
+	Automatically update document styles	Автоматически обновлять стили документа
+	Organizer…	Организатор…
+	1. Formatting restrictions	1. Ограничения форматирования
+	2. Editing restrictions	2. Ограничения редактирования
+	3. Start enforcement	3. Включение защиты
+	<< Less	<< Меньше
+	Another file	Другой файл
+	Apply as you type	Применять при вводе
+	AutoCorrect	Автозамена
+	AutoFormat As You Type	Автоформат при вводе
+	Automatic bulleted lists	Автоматические маркированные списки
+	Automatic numbered lists	Автоматические нумерованные списки
+	Border lines	Линии границ
+	Capitalize first letter of sentences	Делать первые буквы предложений прописными
+	Capitalize first letter of table cells	Делать первые буквы ячеек таблиц прописными
+	Capitalize names of days	Названия дней с прописной буквы
+	Case changes	Изменения регистра
+	Character level	На уровне символов
+	Checked styles are allowed:	Разрешённые стили (отмечены):
+	Combine Documents	Объединение документов
+	Compare Documents	Сравнение документов
+	Compared: {changes} changes	Сравнение завершено: изменений — {changes}
+	Comparing with another file needs the desktop app.	Для сравнения с другим файлом нужно настольное приложение.
+	Comparison settings	Параметры сравнения
+	Don't capitalize after:	Не делать прописной после:
+	Editing in this document is restricted.	Редактирование этого документа ограничено.
+	Every change is recorded as a tracked change.	Каждое изменение записывается как исправление.
+	Everyone	Все
+	Exceptions (optional)	Исключения (необязательно)
+	Exceptions…	Исключения…
+	Fields	Поля
+	Filling in forms	Заполнение форм
+	Find Next Editable Region	Найти следующую область для редактирования
+	Footnotes and endnotes	Сноски и концевые сноски
+	Formatting, case changes, white space and tables are compared; the other settings are kept for later.	Сравниваются форматирование, регистр, пробелы и таблицы; остальные параметры сохраняются на будущее.
+	Fractions (1/2) as fraction characters (½)	Дроби (1/2) как символы дробей (½)
+	Headers and footers	Колонтитулы
+	Hyphens (--) as dashes (—)	Дефисы (--) как тире (—)
+	In equations, typing a name after a backslash replaces it with its symbol.	В формулах имя после обратной косой черты заменяется символом.
+	Internet addresses as links	Адреса в Интернете как ссылки
+	Label changes with:	Подписывать изменения:
+	Limit formatting to a selection of styles	Ограничить форматирование выбранными стилями
+	Math AutoCorrect	Автозамена математическими символами
+	More >>	Больше >>
+	Moves	Перемещения
+	New document	Новый документ
+	No changes (read only)	Без изменений (только чтение)
+	Only allow this kind of editing:	Разрешить только такой способ редактирования:
+	Only comments can be added, except in regions marked editable.	Можно только добавлять примечания, кроме областей, помеченных как редактируемые.
+	Only form fields can be filled in.	Можно заполнять только поля форм.
+	Only the allowed styles can be applied.	Можно применять только разрешённые стили.
+	Ordinals (1st) as superscript	Порядковые числительные (1st) как надстрочные
+	Original document	Исходный документ
+	This password type isn't supported.	Этот тип пароля не поддерживается.
+	Replace as you type	Заменять при вводе
+	Replace text as you type	Заменять текст при вводе
+	Replace:	Заменить:
+	Revised document	Изменённый документ
+	Select text, then tick who can still edit it.	Выделите текст и отметьте, кто может его редактировать.
+	Settings…	Параметры…
+	Show changes at:	Показывать изменения:
+	Show changes in:	Показывать изменения в:
+	Smart quotes instead of straight quotes	«Умные» кавычки вместо прямых
+	Start Enforcing Protection	Включить защиту
+	Stop Protection	Отключить защиту
+	Text boxes	Надписи
+	The document is read only, except for regions marked editable.	Документ доступен только для чтения, кроме областей, помеченных как редактируемые.
+	The password is optional; without it anyone can stop the protection.	Пароль необязателен; без него любой может отключить защиту.
+	This document	Этот документ
+	Tracked changes	Исправления
+	Type the password to stop the protection.	Введите пароль, чтобы отключить защиту.
+	White space	Пробелы
+	With:	На:
+	Word level	На уровне слов
+	Change Chart Type	Изменить тип диаграммы
+	Chart Design	Конструктор диаграмм
+	Type	Тип
+	Edit Data	Изменить данные
+	Chart Title	Название диаграммы
+	Chart Layouts	Макеты диаграмм
+	Add Chart Element	Добавить элемент диаграммы
+	Legend	Легенда
+	Data Labels	Подписи данных
+	Above Chart	Над диаграммой
+	Insert Chart	Вставка диаграммы
+	Clustered Column	Гистограмма с группировкой
+	Stacked Column	Гистограмма с накоплением
+	Clustered Bar	Линейчатая с группировкой
+	Stacked Bar	Линейчатая с накоплением
+	Area	С областями
+	Pie	Круговая
+	Doughnut	Кольцевая
+	Scatter	Точечная
+	“{text}” ({row}, {series}) isn't a number.	«{text}» ({row}, {series}) — не число.
+	Category {n}	Категория {n}
+	Series {n}	Ряд {n}
+	Type the categories down the side and a column of values per series.	Введите категории по вертикали и столбец значений для каждого ряда.
+	Categories	Категории
+	Series name	Имя ряда
+	Remove series	Удалить ряд
+	Remove row	Удалить строку
+	Add Row	Добавить строку
+	Add Series	Добавить ряд
+	Edit\nData	Изменить\nданные
+	Change\nChart Type	Изменить\nтип диаграммы
 	Align Text	Выравнивание текста
 	Create Link	Создать связь
 	Break Link	Разорвать связь
@@ -1846,3 +2138,293 @@ preview	Title	Пример
 	Do Not Check Spelling or Grammar	Не проверять орфографию и грамматику
 	English (United Kingdom)	Английский (Великобритания)
 	Polish	Польский
+
+# Built-in file browser (#576).
+	Documents	Документы
+	Word document	Документ Word
+	All files	Все файлы
+	Recipient lists	Списки получателей
+	The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity.	Системное диалоговое окно выбора файлов недоступно, поэтому WordCraft показывает собственное. Чтобы пользоваться системным, установите портал выбора файлов (например, xdg-desktop-portal-gtk) или zenity.
+	Up one level	На уровень вверх
+	Home folder	Домашняя папка
+	{name} wasn't found.	{name} не найден.
+	{name} already exists. Choose Save again to replace it.	{name} уже существует. Чтобы заменить его, снова выберите «Сохранить».
+	This folder can't be read: {error}	Не удаётся прочитать папку: {error}
+	Showing the first {count} items.	Показаны первые элементы: {count}.
+	File name:	Имя файла:
+	Browse in WordCraft…	Обзор в WordCraft…
+	Open a file with WordCraft's own browser when the system file dialog doesn't appear.	Открыть файл во встроенном обозревателе WordCraft, если системное диалоговое окно выбора файлов не появляется.
+	Hide White Space	Скрыть пустое место между страницами
+	All pages	Все страницы
+	Current page	Текущая страница
+	Selected pages	Выбранные страницы
+	Custom range	Свой диапазон
+	All pages in the range	Все страницы диапазона
+	Odd pages only	Только нечётные страницы
+	Even pages only	Только чётные страницы
+	Copies	Копии
+	Collate copies	Разобрать по копиям
+	Pages like 1-3, 5	Страницы, например 1-3, 5
+	{count} of {total} pages will print	Будет напечатано страниц: {count} из {total}
+	Save these pages as PDF…	Сохранить эти страницы как PDF…
+	The printer, two-sided printing and pages per sheet are chosen in that dialog.	Принтер, двусторонняя печать и число страниц на листе выбираются в этом диалоге.
+	Previous Page	Предыдущая страница
+	Print to PDF	Печать в PDF
+# Word XML Document (#548).
+	Word XML Document (*.xml)	Документ Word XML (*.xml)
+# Find and Replace special characters and wildcards (#543).
+	Use wildcards	Подстановочные знаки
+	Special	Специальный
+	Match prefix	Начало слова
+	Match suffix	Конец слова
+	Ignore punctuation characters	Не учитывать знаки препинания
+	Ignore white-space characters	Не учитывать пробелы
+	Regular expressions	Регулярные выражения
+	Search Options	Параметры поиска
+	Tab Character	Знак табуляции
+	Any Character	Любой знак
+	Any Digit	Любая цифра
+	Any Letter	Любая буква
+	Caret Character	Знак вставки (^)
+	Section Character	Знак раздела
+	Paragraph Character	Знак абзаца
+	Graphic	Графический объект
+	Manual Line Break	Разрыв строки
+	Manual Page Break	Разрыв страницы
+	Section Break	Разрыв раздела
+	White Space	Пробельный знак
+	Clipboard Contents	Содержимое буфера обмена
+	Find What Text	Текст для поиска
+	Find What Expression	Найденное выражение
+	Character in Range	Знак из диапазона
+	Beginning of Word	Начало слова
+	End of Word	Конец слова
+	Expression	Выражение
+	Not	Не
+	Num Occurrences	Число вхождений
+	Previous 1 or More	Предыдущий знак 1 или более раз
+	0 or More Characters	0 или более знаков
+# Insert SmartArt (#497).
+	Add Shape	Добавить фигуру
+	Change Colors	Изменить цвета
+	Change Layout	Изменить макет
+	Create Graphic	Создать графический элемент
+	Edit Items	Изменить элементы
+	Layouts	Макеты
+	Reset Graphic	Сбросить графический элемент
+	SmartArt Design	Конструктор SmartArt
+	SmartArt Styles	Стили SmartArt
+	Text Pane	Область текста
+	List	Список
+	Process	Процесс
+	Cycle	Цикл
+	Hierarchy	Иерархия
+	Relationship	Связь
+	Pyramid	Пирамида
+	Basic List	Простой список
+	Basic Process	Простой процесс
+	Basic Cycle	Простой цикл
+	Basic Pyramid	Простая пирамида
+	Basic Radial	Простая радиальная схема
+	Basic Matrix	Простая матрица
+	Basic Venn	Простая диаграмма Венна
+	Shows items of equal weight as blocks in rows.	Показывает равнозначные элементы блоками в строках.
+	Shows steps in order, left to right, with arrows between them.	Показывает шаги по порядку слева направо со стрелками между ними.
+	Shows steps that repeat, around a circle.	Показывает повторяющиеся шаги по кругу.
+	Shows a tree: each item below the item it belongs to.	Показывает дерево: каждый элемент находится под тем, к которому относится.
+	Shows parts that build on each other, largest at the bottom.	Показывает части, опирающиеся друг на друга; самая крупная внизу.
+	Shows items around a central idea: the first item is the centre.	Показывает элементы вокруг центральной идеи: первый элемент в центре.
+	Shows parts of a whole as quadrants.	Показывает части целого в виде четвертей.
+	Shows overlapping ideas as overlapping circles.	Показывает пересекающиеся идеи в виде пересекающихся кругов.
+	Accent {n}	Акцент {n}
+	Colorful	Разноцветный
+	Insert SmartArt	Вставка SmartArt
+	One line per item. Enter adds an item.	Одна строка на элемент. Enter добавляет элемент.
+	Add\nShape	Добавить\nфигуру
+	Change\nColors	Изменить\nцвета
+	Reset\nGraphic	Сбросить\nграфику
+# Outline view (#493).
+	Promote to Heading 1	Повысить до заголовка 1
+	Demote to Body Text	Понизить до обычного текста
+	Move Up	Переместить вверх
+	Move Down	Переместить вниз
+	Collapse	Свернуть
+	Expand or Collapse Heading	Развернуть или свернуть заголовок
+	Select Heading and Content	Выделить заголовок и содержимое
+	Show Level	Показать уровень
+	Show Level 1	Показать уровень 1
+	Show Level 2	Показать уровень 2
+	Show Level 3	Показать уровень 3
+	Show Level 4	Показать уровень 4
+	Show Level 5	Показать уровень 5
+	Show Level 6	Показать уровень 6
+	Show Level 7	Показать уровень 7
+	Show Level 8	Показать уровень 8
+	Show Level 9	Показать уровень 9
+	Show All Levels	Показать все уровни
+	All Levels	Все уровни
+	Show First Line Only	Показывать только первую строку
+	Show Text Formatting	Показывать форматирование текста
+	Close Outline View	Закрыть режим структуры
+	Outline State	Состояние структуры
+	Outlining	Структура
+	Outline Tools	Работа со структурой
+	Close Outline\nView	Закрыть режим\nструктуры
+# Wrap Text context menu (#513).
+	Move with Text	Перемещать вместе с текстом
+	Fix Position on Page	Зафиксировать положение на странице
+# Paragraph dialog options (#512).
+	Formatting exceptions	Исключения форматирования
+	Inside:	Внутри:
+	Mirror indents	Зеркальные отступы
+	Outside:	Снаружи:
+# WordArt and connectors (#416).
+	WordArt Styles	Стили WordArt
+	Text Fill	Заливка текста
+	Text Outline	Контур текста
+	Transform	Трансформация
+	No Fill	Нет заливки
+	No Outline	Нет контура
+	Reflection	Отражение
+	No Reflection	Без отражения
+	No Transform	Без трансформации
+	Connect Shapes	Соединить фигуры
+	Straight Connector	Прямая соединительная линия
+	Straight Arrow Connector	Прямая соединительная линия со стрелкой
+	Elbow Connector	Уголковая соединительная линия
+	Elbow Arrow Connector	Уголковая линия со стрелкой
+	Curved Connector	Кривая соединительная линия
+	Curved Arrow Connector	Кривая линия со стрелкой
+	Arch Up	Арка вверх
+	Arch Down	Арка вниз
+	Slant Up	Наклон вверх
+	Slant Down	Наклон вниз
+	Inflate	Раздувание
+	Deflate	Сжатие
+	Chevron Up	Шеврон вверх
+	Chevron Down	Шеврон вниз
+	Triangle Up	Треугольник вверх
+	Triangle Down	Треугольник вниз
+	Solid Accent	Сплошной акцент
+	Light with Outline	Светлый с контуром
+	Hollow	Полый
+	Accent Gradient	Градиент акцента
+	Dark with Shadow	Тёмный с тенью
+	Soft Glow	Мягкое свечение
+	Accent with Reflection	Акцент с отражением
+	Warm Gradient with Outline	Тёплый градиент с контуром
+	Add line numbering	Добавить нумерацию строк
+	Add to Document	Добавить в документ
+	Address labels	Адресные наклейки
+	Arabic	Арабский
+	Auto	Авто
+	Automatically hyphenate document	Автоматически расставлять переносы в документе
+	Chinese (Simplified)	Китайский (упрощённый)
+	Chinese (Traditional)	Китайский (традиционный)
+	Column:	Столбец:
+	Count by:	Шаг:
+	Czech	Чешский
+	Danish	Датский
+	Delivery address:	Адрес получателя:
+	Detect language automatically	Определять язык автоматически
+	Do not check spelling or grammar	Не проверять орфографию и грамматику
+	Dutch	Нидерландский
+	Envelope size:	Размер конверта:
+	Estonian	Эстонский
+	Finnish	Финский
+	French (France)	Французский (Франция)
+	From text:	От текста:
+	Full page of the same label	Целая страница одинаковых наклеек
+	German (Germany)	Немецкий (Германия)
+	Greek	Греческий
+	Hebrew	Иврит
+	Hyphenate at:	Переносить по:
+	Hyphenate words in CAPS	Переносить слова из ПРОПИСНЫХ букв
+	Hyphenation Options…	Параметры расстановки переносов…
+	Hyphenation zone:	Зона переноса слов:
+	Italian	Итальянский
+	Japanese	Японский
+	Korean	Корейский
+	Limit consecutive hyphens to:	Максимум последовательных переносов:
+	Line Numbering Options…	Параметры нумерации строк…
+	Manual Hyphenation	Расстановка переносов вручную
+	Manual hyphenation is complete.	Расстановка переносов вручную завершена.
+	Manual…	Вручную…
+	Mark selected text as:	Пометить выделенный текст как:
+	New Document	Новый документ
+	No limit	Без ограничения
+	Norwegian (Bokmål)	Норвежский (букмол)
+	Numbering:	Нумерация:
+	Omit	Пропустить
+	One label per recipient	Одна наклейка на получателя
+	Portuguese (Brazil)	Португальский (Бразилия)
+	Portuguese (Portugal)	Португальский (Португалия)
+	Return address labels	Наклейки с обратным адресом
+	Return address:	Обратный адрес:
+	Row:	Строка:
+	Russian	Русский
+	Serbian (Cyrillic)	Сербский (кириллица)
+	Serbian (Latin)	Сербский (латиница)
+	Set As Default	Использовать по умолчанию
+	Shipping labels	Транспортные наклейки
+	Single label	Одна наклейка
+	Spanish (Mexico)	Испанский (Мексика)
+	Spanish (Spain)	Испанский (Испания)
+	Swedish	Шведский
+	Turkish	Турецкий
+	Ukrainian	Украинский
+	{language} is now the document's default language.	{language} теперь язык документа по умолчанию.
+# File > Options panes (#485).
+	As you type	По мере ввода
+	AutoSave writes your changes to the file a moment after you stop typing.	Автосохранение записывает изменения в файл вскоре после того, как вы перестанете печатать.
+	Centimeters	Сантиметры
+	Check spelling as you type	Проверять орфографию при вводе
+	Click to switch back to inserting	Нажмите, чтобы вернуться к вставке
+	Custom dictionary	Пользовательский словарь
+	Formatting marks	Знаки форматирования
+	Hidden text	Скрытый текст
+	Ignore web and file addresses	Пропускать веб-адреса и пути к файлам
+	Ignore words in capitals	Пропускать слова из прописных букв
+	Ignore words with numbers	Пропускать слова с цифрами
+	Inches	Дюймы
+	Initials:	Инициалы:
+	Interface	Интерфейс
+	Interface language	Язык интерфейса
+	Mark grammar errors as you type	Отмечать грамматические ошибки при вводе
+	Measurement units:	Единицы измерения:
+	Millimeters	Миллиметры
+	New comments and tracked changes are recorded under this name and these initials.	Новые примечания и исправления записываются под этим именем и инициалами.
+	New word	Новое слово
+	No words yet. Add to Dictionary on a misspelled word puts it here.	Слов пока нет. Команда «Добавить в словарь» для слова с ошибкой помещает его сюда.
+	Overtype	Замена
+	Overtype (typing replaces the characters after the caret)	Замена (вводимый текст заменяет символы после курсора)
+	Page display	Отображение страницы
+	Paragraph marks	Знаки абзаца
+	Personalize	Персонализация
+	Picas	Пики
+	Points	Пункты
+	Print the page color	Печатать цвет страницы
+	Printing	Печать
+	Proofing language	Язык проверки правописания
+	Recent documents to show:	Число недавних документов:
+	Save documents	Сохранение документов
+	Show the mini toolbar when text is selected	Показывать мини-панель при выделении текста
+	Spaces	Пробелы
+	Spelling	Орфография
+	Spelling and grammar are checked in English (United States).	Орфография и грамматика проверяются для английского языка (США).
+	Tab characters	Знаки табуляции
+	These marks show even when Show/Hide ¶ is off.	Эти знаки видны, даже когда «Показать все знаки» выключено.
+	Typing replaces selected text	Ввод заменяет выделенный текст
+	Update fields before printing	Обновлять поля перед печатью
+	Use the Insert key to switch overtype on and off	Клавиша Insert включает и выключает режим замены
+# Asian and Latin text fonts (#505).
+	Asian text font:	Шрифт азиатского текста:
+	Latin text font:	Шрифт латинского текста:
+	Visual effects	Визуальные эффекты
+	Animation effects:	Эффекты анимации:
+	On	Включено
+	Off	Выключено
+	Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.	Плавная прокрутка и масштабирование, а также плавное появление меню и кнопок. Если выбрано «Выключено», все изменения отображаются сразу.
+	Your system has animation effects turned on.	В системе эффекты анимации включены.
+	Your system has animation effects turned off.	В системе эффекты анимации выключены.
+	Your system doesn't report an animation setting, so animation effects stay on.	Система не сообщает о настройке анимации, поэтому эффекты анимации остаются включёнными.
diff --git a/crates/ui-egui/src/i18n/sr-latn.tsv b/crates/ui-egui/src/i18n/sr-latn.tsv
index 99a28b84b0..a8f3d37e10 100644
--- a/crates/ui-egui/src/i18n/sr-latn.tsv
+++ b/crates/ui-egui/src/i18n/sr-latn.tsv
@@ -65,12 +65,15 @@
 	Arrow	Strelica
 	Artistic Effects	Umetnički efekti
 	As Recommended	Kao što je preporučeno
+	As you type	Tokom kucanja
+	Asian text font:	Font azijskog teksta:
 	Asian Typography	Azijska tipografija
 	Author	Autor
 	AutoCorrect Options	Opcije automatske ispravke
 	AutoFit	Automatsko uklapanje
 	AutoFit Contents	Automatski uklopi prema sadržaju
 	AutoFit Window	Automatski uklopi prema prozoru
+	AutoSave writes your changes to the file a moment after you stop typing.	Automatsko čuvanje upisuje izmene u datoteku čim prestanete da kucate.
 	Automatic	Automatski
 	Automatic ({language})	Automatski ({language})
 	Automatic follows your system's language. Menus and commands change; your documents don't.	Automatski prati jezik sistema. Meniji i naredbe se menjaju; dokumenti ne.
@@ -81,6 +84,8 @@
 	AutoSave failed: {error}. Save the document to turn AutoSave back on.	Automatsko čuvanje neuspelo: {error}. Sačuvajte dokument da biste ga ponovo uključili.
 	Balloons	Oblačići
 	Bottom Margin	Donja margina
+	Centimeters	Centimetri
+	Check spelling as you type	Proveravaj pravopis tokom kucanja
 	Click a border between two cells to merge them. Esc stops.	Kliknite ivicu između dve ćelije da ih spojite. Esc završava.
 	Based on: {style}	Zasnovan na: {style}
 	Built-in style	Ugrađeni stil
@@ -92,12 +97,14 @@
 	Character style	Stil znakova
 	Click an item to paste it.	Kliknite na stavku da biste je nalepili.
 	Click level to modify:	Kliknite nivo koji menjate:
+	Click to switch back to inserting	Kliknite da biste se vratili na umetanje
 	Clipboard Items	Stavke ostave
 	Clipboard Pane	Okno ostave
 	Color only	Samo boja
 	Color: {color}	Boja: {color}
 	Compress punctuation at the start of a line	Sažmi interpunkciju na početku reda
 	Confirm password:	Potvrdite lozinku:
+	Custom dictionary	Prilagođeni rečnik
 	Dark page (white text on black)	Tamna stranica (beo tekst na crnom)
 	Drag a rectangle to draw a table, or a line across cells to split them. Esc stops.	Prevucite pravougaonik da nacrtate tabelu ili liniju preko ćelija da ih podelite. Esc završava.
 	Draw Table	Nacrtaj tabelu
@@ -108,20 +115,52 @@
 	Enter formatting for number:	Oblik broja:
 	Follow number with:	Posle broja:
 	Formatting	Oblikovanje
+	Formatting marks	Oznake oblikovanja
+	Hidden text	Skriveni tekst
+	Ignore web and file addresses	Zanemari veb-adrese i putanje datoteka
+	Ignore words in capitals	Zanemari reči pisane velikim slovima
+	Ignore words with numbers	Zanemari reči sa brojevima
+	Inches	Inči
+	Formatting exceptions	Izuzeci formatiranja
 	Include level number from:	Uključi broj nivoa:
+	Initials:	Inicijali:
 	Ink	Mastilo
 	Insertions and Deletions	Umetanja i brisanja
 	Insertions:	Umetanja:
+	Interface	Interfejs
+	Interface language	Jezik interfejsa
+	Inside:	Unutra:
+	Latin text font:	Font latiničnog teksta:
 	Left border	Leva ivica
 	Left Margin	Leva margina
 	Legal style numbering	Pravno numerisanje
 	Link level to style:	Poveži nivo sa stilom:
 	List Definition	Definicija liste
+	Mark grammar errors as you type	Označavaj gramatičke greške tokom kucanja
+	Measurement units:	Jedinice mere:
+	Millimeters	Milimetri
+	New comments and tracked changes are recorded under this name and these initials.	Novi komentari i praćene izmene beleže se pod ovim imenom i inicijalima.
+	New word	Nova reč
+	No words yet. Add to Dictionary on a misspelled word puts it here.	Još nema reči. Dodaj u rečnik na pogrešno napisanoj reči stavlja je ovde.
+	Mirror indents	Preslikaj uvlačenja
 	Nothing	Ništa
 	Number alignment:	Poravnanje broja:
 	Number format	Format broja
 	Number style for this level:	Stil broja za ovaj nivo:
 	Outside border	Spoljna ivica
+	Overtype	Prepisivanje
+	Overtype (typing replaces the characters after the caret)	Prepisivanje (otkucano zamenjuje znakove posle kursora)
+	Page display	Prikaz strane
+	Paragraph marks	Oznake pasusa
+	Personalize	Personalizacija
+	Picas	Pike
+	Points	Tačke
+	Print the page color	Štampaj boju strane
+	Printing	Štampanje
+	Proofing language	Jezik provere pisanja
+	Recent documents to show:	Broj nedavnih dokumenata za prikaz:
+	Remove	Ukloni
+	Outside:	Spolja:
 	Reopen	Ponovo otvori
 	Restart list after:	Ponovo počni listu posle:
 	Right border	Desna ivica
@@ -159,6 +198,7 @@
 	Paste Clipboard Item	Nalepi stavku iz ostave
 	Preview	Pregled
 	Remove Password	Ukloni lozinku
+	Save documents	Čuvanje dokumenata
 	Shadow, glow and soft edges	Senka, sjaj i meke ivice
 	Shape Effects	Efekti oblika
 	Show all revisions inline	Prikaži sve izmene u tekstu
@@ -167,7 +207,6 @@
 	Distribute spacing	Rasporedi razmak
 	Offset (pt):	Pomak (pt):
 	Phonetic Guide	Fonetski vodič
-	Remove	Ukloni
 	Right (vertical)	Desno (vertikalno)
 	Ruby text:	Rubi tekst:
 	Show documents with their colours inverted, like View › Switch Modes. Saving, printing and PDFs are unchanged.	Prikaži dokumente sa invertovanim bojama, kao kod Prikaz › Promeni režim. Čuvanje, štampanje i PDF nisu pogođeni.
@@ -195,6 +234,11 @@
 	Border Painter	Kopiranje ivica
 	Border\nPainter	Kopiranje\nivica
 	Borders	Ivice
+	Show the mini toolbar when text is selected	Prikaži mini traku sa alatkama pri izboru teksta
+	Spaces	Razmaci
+	Spelling	Pravopis
+	Spelling and grammar are checked in English (United States).	Pravopis i gramatika se proveravaju na engleskom (Sjedinjene Države).
+	Tab characters	Znakovi tabulatora
 	Tab stop position:	Položaj tabulatora:
 	Default tab stops:	Podrazumevani tabulatori:
 	Tab stops to be cleared:	Tabulatori za brisanje:
@@ -205,6 +249,10 @@
 	Set	Postavi
 	Page Border	Ivica strane
 	Apply to:	Primeni na:
+	These marks show even when Show/Hide ¶ is off.	Ove oznake se prikazuju i kada je Prikaži/sakrij ¶ isključeno.
+	Typing replaces selected text	Otkucano zamenjuje izabrani tekst
+	Update fields before printing	Ažuriraj polja pre štampanja
+	Use the Insert key to switch overtype on and off	Taster Insert uključuje i isključuje prepisivanje
 	Whole document	Ceo dokument
 	This section	Ovaj odeljak
 	Fill	Ispuna
@@ -380,6 +428,7 @@
 	Export PDF	Izvezi PDF
 	Exported {path}	Izvezeno: {path}
 	Extend Selection	Proširi izbor
+	Extend Selection by Units	Proširi izbor po jedinicama
 	Field	Polje
 	File	Fajl
 	Find	Pronađi
@@ -787,6 +836,9 @@
 	Show or Hide Style	Prikaži ili sakrij stil
 	Show revisions in balloons	Prikaži izmene u oblačićima
 	Show rulers	Prikaži lenjire
+	Animation	Animacija
+	Animate the caret (it glides and fades)	Animiraj kursor (klizi i postepeno se gasi)
+	On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off.	Uključeno: kursor klizi na novo mesto dok kucate ili koristite strelice, a njegovo treptanje se postepeno gasi. Isključeno: skače i trepće naglo.
 	Show the community button in the title bar	Prikaži dugme zajednice u traci naslova
 	Show/Hide ¶	Prikaži/sakrij ¶
 	Show\nComments	Prikaži\nkomentare
@@ -939,10 +991,10 @@
 	Wide	Široko
 	Widow/Orphan Control	Kontrola usamljenih redova
 	Widow/Orphan control	Kontrola usamljenih redova
-	Wildcards (regex)	Džoker znaci (regex)
 	Window	Prozor
 	Word Count	Broj reči
 	Word document (*.docx)	Word dokument (*.docx)
+	Word XML Document (*.xml)	Word XML dokument (*.xml)
 	Word Left	Reč levo
 	Word Right	Reč desno
 	WordArt	WordArt
@@ -1358,8 +1410,86 @@
 	Selected Fields	Izabrana polja
 	Edit Field…	Uredi polje…
 	Formatted	Formatirano
+	Deleted	Izbrisano
 	Interface size:	Veličina interfejsa:
 	Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate.	Povećava ili smanjuje traku, menije i dijaloge, povrh skaliranja ekrana u sistemu. Zumiranje dokumenta je zasebno.
+	Resize Table by Dragging	Promena veličine tabele prevlačenjem
+	Print Markup	Štampaj oznake
+	Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text.	Komentari pored svake stranice i praćene izmene u PDF-ovima, otiscima i slikama; lista komentara na kraju veb-stranica, Markdown-a i teksta.
+
+# Compare / Combine, AutoCorrect Options and Restrict Editing (#412)
+	1. Formatting restrictions	1. Ograničenja oblikovanja
+	2. Editing restrictions	2. Ograničenja uređivanja
+	3. Start enforcement	3. Pokretanje zaštite
+	<< Less	<< Manje
+	Another file	Druga datoteka
+	Apply as you type	Primeni dok kucaš
+	AutoCorrect	Automatska ispravka
+	AutoFormat As You Type	Automatsko oblikovanje tokom kucanja
+	Automatic bulleted lists	Automatske liste sa znakovima
+	Automatic numbered lists	Automatske numerisane liste
+	Border lines	Linije ivica
+	Capitalize first letter of sentences	Veliko prvo slovo rečenice
+	Capitalize first letter of table cells	Veliko prvo slovo u ćelijama tabele
+	Capitalize names of days	Veliko slovo u nazivima dana
+	Case changes	Promene veličine slova
+	Character level	Nivo znaka
+	Checked styles are allowed:	Označeni stilovi su dozvoljeni:
+	Combine Documents	Spajanje dokumenata
+	Compare Documents	Upoređivanje dokumenata
+	Compared: {changes} changes	Upoređeno: izmena {changes}
+	Comparing with another file needs the desktop app.	Za poređenje sa drugom datotekom potrebna je desktop aplikacija.
+	Comparison settings	Podešavanja poređenja
+	Don't capitalize after:	Bez velikog slova posle:
+	Editing in this document is restricted.	Uređivanje ovog dokumenta je ograničeno.
+	Every change is recorded as a tracked change.	Svaka izmena se beleži kao praćena izmena.
+	Everyone	Svi
+	Exceptions (optional)	Izuzeci (neobavezno)
+	Exceptions…	Izuzeci…
+	Fields	Polja
+	Filling in forms	Popunjavanje obrazaca
+	Find Next Editable Region	Pronađi sledeći deo za uređivanje
+	Footnotes and endnotes	Fusnote i krajnje napomene
+	Formatting, case changes, white space and tables are compared; the other settings are kept for later.	Porede se oblikovanje, veličina slova, razmaci i tabele; ostala podešavanja se čuvaju za kasnije.
+	Fractions (1/2) as fraction characters (½)	Razlomci (1/2) kao znakovi razlomka (½)
+	Headers and footers	Zaglavlja i podnožja
+	Hyphens (--) as dashes (—)	Crtice (--) kao crte (—)
+	In equations, typing a name after a backslash replaces it with its symbol.	U jednačinama se naziv otkucan posle obrnute kose crte zamenjuje simbolom.
+	Internet addresses as links	Internet adrese kao veze
+	Label changes with:	Označi izmene sa:
+	Limit formatting to a selection of styles	Ograniči oblikovanje na izabrane stilove
+	Math AutoCorrect	Automatska ispravka matematike
+	More >>	Više >>
+	Moves	Premeštanja
+	New document	Novi dokument
+	No changes (read only)	Bez izmena (samo za čitanje)
+	Only allow this kind of editing:	Dozvoli samo ovu vrstu uređivanja:
+	Only comments can be added, except in regions marked editable.	Mogu se dodavati samo komentari, osim u delovima označenim za uređivanje.
+	Only form fields can be filled in.	Mogu se popuniti samo polja obrasca.
+	Only the allowed styles can be applied.	Mogu se primeniti samo dozvoljeni stilovi.
+	Ordinals (1st) as superscript	Redni brojevi (1st) kao eksponent
+	Original document	Originalni dokument
+	This password type isn't supported.	Ova vrsta lozinke nije podržana.
+	Replace as you type	Zameni dok kucaš
+	Replace text as you type	Zameni tekst dok kucaš
+	Replace:	Zameni:
+	Revised document	Izmenjeni dokument
+	Select text, then tick who can still edit it.	Izaberite tekst, pa označite ko još može da ga uređuje.
+	Settings…	Podešavanja…
+	Show changes at:	Prikaži izmene na nivou:
+	Show changes in:	Prikaži izmene u:
+	Smart quotes instead of straight quotes	Tipografski navodnici umesto pravih
+	Start Enforcing Protection	Pokreni zaštitu
+	Stop Protection	Zaustavi zaštitu
+	Text boxes	Okviri za tekst
+	The document is read only, except for regions marked editable.	Dokument je samo za čitanje, osim delova označenih za uređivanje.
+	The password is optional; without it anyone can stop the protection.	Lozinka nije obavezna; bez nje svako može da zaustavi zaštitu.
+	This document	Ovaj dokument
+	Tracked changes	Praćene izmene
+	Type the password to stop the protection.	Unesite lozinku da biste zaustavili zaštitu.
+	White space	Razmaci
+	With:	Sa:
+	Word level	Nivo reči
 	In Line with Text	U ravni sa tekstom
 	Square	Kvadratno
 	Through	Kroz
@@ -1406,6 +1536,36 @@
 	New Group	Nova grupa
 	Rename…	Preimenuj…
 	Ribbon and Quick Access Toolbar:	Traka i traka sa alatkama za brzi pristup:
+	Add Font…	Dodaj font…
+	Added Fonts	Dodati fontovi
+	Remove Added Font	Ukloni dodati font
+	Recent Colors	Nedavne boje
+	More Colors…	Još boja…
+	Standard	Standardne
+	Current	Trenutna
+	Colors:	Boje:
+	Color model:	Model boja:
+	Red:	Crvena:
+	Green:	Zelena:
+	Blue:	Plava:
+	Hue:	Nijansa:
+	Sat:	Zasićenost:
+	Lum:	Osvetljenost:
+	Hex:	Heks:
+	Accessibility Pane	Okno pristupačnosti
+	Alt Text Pane	Okno alternativnog teksta
+	Alt\nText	Alternativni\ntekst
+	View Alt Text…	Prikaži alternativni tekst…
+	Mark as decorative	Označi kao dekorativno
+	Title:	Naslov:
+	Errors ({n})	Greške ({n})
+	Warnings ({n})	Upozorenja ({n})
+	Tips ({n})	Saveti ({n})
+	No accessibility issues found.	Nije pronađen nijedan problem pristupačnosti.
+	Describe what this object shows, for people who can't see it.	Opišite šta ovaj objekat prikazuje, za one koji ne mogu da ga vide.
+	Decorative objects only add visual interest: screen readers skip them.	Dekorativni objekti samo doprinose izgledu: čitači ekrana ih preskaču.
+	Describe what this table shows, for people who can't see it.	Opišite šta ova tabela prikazuje, za one koji ne mogu da je vide.
+	Select a picture, shape, chart or table to describe it.	Izaberite sliku, oblik, grafikon ili tabelu da biste ih opisali.
 	Document Grid	Mreža dokumenta
 	No grid	Bez mreže
 	Lines only	Samo redovi
@@ -1415,6 +1575,39 @@
 	Lines per page:	Redova po stranici:
 	Moved from	Premešteno odavde
 	Moved to	Premešteno ovde
+	Developer	Programer
+	Controls	Kontrole
+	Rich Text Content Control	Kontrola sadržaja za obogaćeni tekst
+	Plain Text Content Control	Kontrola sadržaja za običan tekst
+	Picture Content Control	Kontrola sadržaja za sliku
+	Building Block Gallery Content Control	Kontrola sadržaja za galeriju gradivnih blokova
+	Check Box Content Control	Kontrola sadržaja za polje za potvrdu
+	Combo Box Content Control	Kontrola sadržaja za kombinovano polje
+	Drop-Down List Content Control	Kontrola sadržaja za padajuću listu
+	Date Picker Content Control	Kontrola sadržaja za biranje datuma
+	Repeating Section Content Control	Kontrola sadržaja za odeljak koji se ponavlja
+	Design Mode	Režim dizajna
+	Content Control at Selection	Kontrola sadržaja na izboru
+	Toggle Check Box	Promeni polje za potvrdu
+	Choose List Item	Izaberi stavku liste
+	Set Date	Postavi datum
+	Remove Content Control	Ukloni kontrolu sadržaja
+	Content Control Properties	Svojstva kontrole sadržaja
+	Title	Naslov
+	Tag	Oznaka
+	Placeholder text	Tekst čuvara mesta
+	Can't be deleted	Ne može da se izbriše
+	Contents can't be edited	Sadržaj ne može da se uređuje
+	Remove the control once edited	Ukloni kontrolu posle uređivanja
+	Allow line breaks	Dozvoli prelome reda
+	Date format	Format datuma
+	Checked symbol	Simbol za potvrđeno
+	Unchecked symbol	Simbol za nepotvrđeno
+	List entries	Stavke liste
+	Display text	Prikazani tekst
+	Value	Vrednost
+	Today	Danas
+	Put the caret in a content control first.	Prvo postavite kursor u kontrolu sadržaja.
 	Right-to-Left Table	Tabela sa desna na levo
 	Right-to-Left Section	Odeljak sa desna na levo
 	Table direction:	Smer tabele:
@@ -1442,6 +1635,50 @@
 	Enlarge symbol	Uvećaj simbol
 	Enclosure	Okvir
 	Circle	Krug
+	Templates	Šabloni
+	Templates and Add-ins	Šabloni i dodaci
+	Attach Template	Priloži šablon
+	Detach Template	Ukloni šablon
+	Automatically Update Document Styles	Automatski ažuriraj stilove dokumenta
+	Update Styles from Template	Ažuriraj stilove iz šablona
+	Organizer	Organizator
+	Copy Styles	Kopiraj stilove
+	Rename Style	Preimenuj stil
+	Document template:	Šablon dokumenta:
+	Attach…	Priloži…
+	Automatically update document styles	Automatski ažuriraj stilove dokumenta
+	Organizer…	Organizator…
+	Change Chart Type	Promeni tip grafikona
+	Chart Design	Dizajn grafikona
+	Type	Tip
+	Edit Data	Uredi podatke
+	Chart Title	Naslov grafikona
+	Chart Layouts	Rasporedi grafikona
+	Add Chart Element	Dodaj element grafikona
+	Legend	Legenda
+	Data Labels	Oznake podataka
+	Above Chart	Iznad grafikona
+	Insert Chart	Umetni grafikon
+	Clustered Column	Grupisane kolone
+	Stacked Column	Naslagane kolone
+	Clustered Bar	Grupisane trake
+	Stacked Bar	Naslagane trake
+	Area	Površinski
+	Pie	Kružni
+	Doughnut	Prstenasti
+	Scatter	Raspršeni
+	“{text}” ({row}, {series}) isn't a number.	„{text}” ({row}, {series}) nije broj.
+	Category {n}	Kategorija {n}
+	Series {n}	Serija {n}
+	Type the categories down the side and a column of values per series.	Unesite kategorije sa strane i po jednu kolonu vrednosti za svaku seriju.
+	Categories	Kategorije
+	Series name	Naziv serije
+	Remove series	Ukloni seriju
+	Remove row	Ukloni red
+	Add Row	Dodaj red
+	Add Series	Dodaj seriju
+	Edit\nData	Uredi\npodatke
+	Change\nChart Type	Promeni tip\ngrafikona
 	Align Text	Poravnaj tekst
 	Create Link	Napravi vezu
 	Break Link	Prekini vezu
@@ -1466,3 +1703,346 @@
 	English (United Kingdom)	Engleski (Velika Britanija)
 	Polish	Poljski
 	Do Not Check Spelling or Grammar	Ne proveravaj pravopis i gramatiku
+
+# Built-in file browser when the system file dialog is unavailable (#576)
+	Documents	Dokumenti
+	Word document	Word dokument
+	All files	Sve datoteke
+	Recipient lists	Liste primalaca
+	The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity.	Sistemski dijalog za datoteke nije dostupan, pa WordCraft prikazuje svoj. Da biste dobili sistemski dijalog, instalirajte portal za izbor datoteka (na primer xdg-desktop-portal-gtk) ili zenity.
+	Up one level	Jedan nivo gore
+	Home folder	Lična fascikla
+	{name} wasn't found.	{name} nije pronađen.
+	{name} already exists. Choose Save again to replace it.	{name} već postoji. Izaberite Sačuvaj ponovo da biste zamenili datoteku.
+	This folder can't be read: {error}	Ova fascikla ne može da se pročita: {error}
+	Showing the first {count} items.	Prikazane su samo prve stavke: {count}.
+	File name:	Ime datoteke:
+	Browse in WordCraft…	Potraži u WordCraft-u…
+	Open a file with WordCraft's own browser when the system file dialog doesn't appear.	Otvorite datoteku pomoću WordCraft-ovog pregledača kada se sistemski dijalog za datoteke ne pojavi.
+	Hide White Space	Sakrij prazan prostor
+	All pages	Sve stranice
+	Current page	Trenutna stranica
+	Selected pages	Izabrane stranice
+	Custom range	Prilagođeni opseg
+	All pages in the range	Sve stranice u opsegu
+	Odd pages only	Samo neparne stranice
+	Even pages only	Samo parne stranice
+	Copies	Kopije
+	Collate copies	Složi kopije
+	Pages like 1-3, 5	Stranice poput 1-3, 5
+	{count} of {total} pages will print	Štampaće se {count} od {total} stranica
+	Save these pages as PDF…	Sačuvaj ove stranice kao PDF…
+	The printer, two-sided printing and pages per sheet are chosen in that dialog.	Štampač, obostrana štampa i broj stranica po listu biraju se u tom dijalogu.
+	Previous Page	Prethodna stranica
+	Print to PDF	Štampaj u PDF
+	Add Shape	Dodaj oblik
+	Change Colors	Promeni boje
+	Change Layout	Promeni raspored
+	Create Graphic	Kreiranje grafike
+	Edit Items	Uredi stavke
+	Layouts	Rasporedi
+	Reset Graphic	Resetuj grafiku
+	SmartArt Design	SmartArt dizajn
+	SmartArt Styles	SmartArt stilovi
+	Text Pane	Okno za tekst
+	List	Lista
+	Process	Proces
+	Cycle	Ciklus
+	Hierarchy	Hijerarhija
+	Relationship	Odnos
+	Pyramid	Piramida
+	Basic List	Osnovna lista
+	Basic Process	Osnovni proces
+	Basic Cycle	Osnovni ciklus
+	Basic Pyramid	Osnovna piramida
+	Basic Radial	Osnovni radijalni
+	Basic Matrix	Osnovna matrica
+	Basic Venn	Osnovni Venov dijagram
+	Shows items of equal weight as blocks in rows.	Prikazuje stavke jednake važnosti kao blokove u redovima.
+	Shows steps in order, left to right, with arrows between them.	Prikazuje korake redom, sleva nadesno, sa strelicama između njih.
+	Shows steps that repeat, around a circle.	Prikazuje korake koji se ponavljaju, oko kruga.
+	Shows a tree: each item below the item it belongs to.	Prikazuje stablo: svaka stavka ispod stavke kojoj pripada.
+	Shows parts that build on each other, largest at the bottom.	Prikazuje delove koji se oslanjaju jedan na drugi, najveći na dnu.
+	Shows items around a central idea: the first item is the centre.	Prikazuje stavke oko centralne ideje: prva stavka je u sredini.
+	Shows parts of a whole as quadrants.	Prikazuje delove celine kao kvadrante.
+	Shows overlapping ideas as overlapping circles.	Prikazuje ideje koje se preklapaju kao krugove koji se preklapaju.
+	Accent {n}	Akcenat {n}
+	Colorful	Šareno
+	Insert SmartArt	Umetni SmartArt
+	One line per item. Enter adds an item.	Jedan red po stavci. Enter dodaje stavku.
+	Add\nShape	Dodaj\noblik
+	Change\nColors	Promeni\nboje
+	Reset\nGraphic	Resetuj\ngrafiku
+	Promote to Heading 1	Podigni na Naslov 1
+	Demote to Body Text	Spusti na osnovni tekst
+	Move Up	Pomeri nagore
+	Move Down	Pomeri nadole
+	Collapse	Skupi
+	Expand or Collapse Heading	Proširi ili skupi naslov
+	Select Heading and Content	Izaberi naslov i sadržaj
+	Show Level	Prikaži nivo
+	Show Level 1	Prikaži nivo 1
+	Show Level 2	Prikaži nivo 2
+	Show Level 3	Prikaži nivo 3
+	Show Level 4	Prikaži nivo 4
+	Show Level 5	Prikaži nivo 5
+	Show Level 6	Prikaži nivo 6
+	Show Level 7	Prikaži nivo 7
+	Show Level 8	Prikaži nivo 8
+	Show Level 9	Prikaži nivo 9
+	Show All Levels	Prikaži sve nivoe
+	All Levels	Svi nivoi
+	Show First Line Only	Prikaži samo prvi red
+	Show Text Formatting	Prikaži oblikovanje teksta
+	Close Outline View	Zatvori prikaz konture
+	Outline State	Stanje konture
+	Outlining	Kontura
+	Outline Tools	Alatke konture
+	Close Outline\nView	Zatvori prikaz\nkonture
+	A, B, C, …	A, B, C, …
+	Above the item	Iznad stavke
+	Accessed on	Pristupljeno
+	Add New Source…	Dodaj novi izvor…
+	Add the chapter number	Dodaj broj poglavlja
+	Atmosphere	Atmosfera
+	Below the item	Ispod stavke
+	Book	Knjiga
+	Book title	Naslov knjige
+	Caption	Natpis
+	Caption Numbering	Numerisanje natpisa
+	Caption text	Tekst natpisa
+	Caption:	Natpis:
+	Chapter in a book	Poglavlje u knjizi
+	Chapters begin at:	Poglavlja počinju na:
+	Collect entries from:	Stavke uzeti iz:
+	Columns:	Kolone:
+	Conference	Konferencija
+	Conference paper	Rad sa konferencije
+	Container Title	Naslov zbirke
+	Create Source	Napravi izvor
+	Cross-reference:	Unakrsna referenca:
+	Custom Table of Contents…	Prilagođeni sadržaj…
+	DOI	DOI
+	Day	Dan
+	Delete Label	Obriši oznaku
+	Edit Source	Uredi izvor
+	Edition	Izdanje
+	Edit…	Uredi…
+	Entry marked.	Stavka je označena.
+	Example: {sample}	Primer: {sample}
+	Figure	Slika
+	Film	Film
+	Heading styles (levels 1–{n})	Stilovi naslova (nivoi 1–{n})
+	Heading {n}	Naslov {n}
+	I, II, III, …	I, II, III, …
+	Include page numbers	Uključi brojeve stranica
+	Indented	Uvučeno
+	Institution	Institucija
+	Ionosphere	Jonosfera
+	Issue	Broj
+	Journal	Časopis
+	Label:	Oznaka:
+	Last, First; Last, First	Prezime, Ime; Prezime, Ime
+	Leave the label out of the caption	Izostavi oznaku iz natpisa
+	Letter headings	Naslovi po slovima
+	Levels:	Nivoi:
+	Link entries to their headings	Poveži stavke sa naslovima
+	Made from the author and year when empty	Ako je prazno, pravi se od autora i godine
+	Magazine or newspaper article	Članak u magazinu ili novinama
+	Main entry:	Glavna stavka:
+	Mark	Označi
+	Mark All	Označi sve
+	Mark Entry…	Označi stavku…
+	Mark Index Entry	Označi stavku indeksa
+	Mesosphere	Mezosfera
+	Month	Mesec
+	New Label	Nova oznaka
+	New Label…	Nova oznaka…
+	New…	Novo…
+	No sources yet.	Još nema izvora.
+	Numbering…	Numerisanje…
+	Options…	Opcije…
+	Other	Drugo
+	Other styles and their TOC level:	Ostali stilovi i njihov nivo u sadržaju:
+	Outline levels	Nivoi strukture
+	Page number style	Stil broja stranice
+	Page numbers at the right margin	Brojevi stranica uz desnu marginu
+	Page title	Naslov stranice
+	Pages of bookmark:	Stranice obeleživača:
+	Periodical	Periodika
+	Position:	Položaj:
+	Publisher	Izdavač
+	Run-in	U nizu
+	See	Vidi
+	Separator:	Razdvajač:
+	Show every bibliography field	Prikaži sva polja bibliografije
+	Site name	Naziv sajta
+	Source Manager	Upravljač izvorima
+	Source type:	Vrsta izvora:
+	Sources in this document:	Izvori u ovom dokumentu:
+	Styles:	Stilovi:
+	Subentry:	Podstavka:
+	TC entry fields	Polja stavki TC
+	Tab leader:	Popuna tabulatora:
+	Table of Contents Options	Opcije sadržaja
+	Table of Contents Styles	Stilovi sadržaja
+	This page	Ova stranica
+	Type:	Vrsta:
+	URL	URL
+	Volume	Tom
+	Website	Veb-sajt
+	Year	Godina
+	a, b, c, …	a, b, c, …
+	i, ii, iii, …	i, ii, iii, …
+	{n} entries marked.	Označeno stavki: {n}.
+	Lasso Select	Izbor lasom
+	Move Selected Ink	Premesti izabrani rukopis
+	Delete Selected Ink	Obriši izabrani rukopis
+	Recolor Selected Ink	Promeni boju izabranog rukopisa
+	Add Pen	Dodaj pero
+	Remove Pen	Ukloni pero
+	Ink to Shape	Rukopis u oblik
+	Convert to Shapes	Pretvori u oblike
+	Ink Replay	Rukopis repriza
+	Add\nPen	Dodaj\npero
+	Rewind	Na početak
+	Forward	Napred
+	Stroke {n} of {total}	Potez {n} od {total}
+	Use wildcards	Koristi džoker znake
+	Special	Posebno
+	Match prefix	Podudari prefiks
+	Match suffix	Podudari sufiks
+	Ignore punctuation characters	Zanemari znake interpunkcije
+	Ignore white-space characters	Zanemari beline
+	Regular expressions	Regularni izrazi
+	Search Options	Opcije pretrage
+	Tab Character	Znak tabulatora
+	Any Character	Bilo koji znak
+	Any Digit	Bilo koja cifra
+	Any Letter	Bilo koje slovo
+	Caret Character	Znak kapice
+	Section Character	Znak odeljka
+	Paragraph Character	Simbol pasusa
+	Graphic	Grafika
+	Manual Line Break	Ručni prekid reda
+	Manual Page Break	Ručni prekid strane
+	Section Break	Prekid odeljka
+	White Space	Belina
+	Clipboard Contents	Sadržaj ostave
+	Find What Text	Pronađeni tekst
+	Find What Expression	Pronađeni izraz
+	Character in Range	Znak u opsegu
+	Beginning of Word	Početak reči
+	End of Word	Kraj reči
+	Expression	Izraz
+	Not	Nije
+	Num Occurrences	Broj ponavljanja
+	Previous 1 or More	Prethodno 1 ili više puta
+	0 or More Characters	0 ili više znakova
+	Move with Text	Pomeraj sa tekstom
+	Fix Position on Page	Fiksiraj položaj na stranici
+
+# WordArt and connectors (#416).
+	WordArt Styles	WordArt stilovi
+	Text Fill	Popuna teksta
+	Text Outline	Kontura teksta
+	Transform	Transformacija
+	No Fill	Bez popune
+	No Outline	Bez konture
+	Reflection	Odraz
+	No Reflection	Bez odraza
+	No Transform	Bez transformacije
+	Connect Shapes	Poveži oblike
+	Straight Connector	Pravi konektor
+	Straight Arrow Connector	Pravi konektor sa strelicom
+	Elbow Connector	Ugaoni konektor
+	Elbow Arrow Connector	Ugaoni konektor sa strelicom
+	Curved Connector	Zakrivljeni konektor
+	Curved Arrow Connector	Zakrivljeni konektor sa strelicom
+	Arch Up	Luk nagore
+	Arch Down	Luk nadole
+	Slant Up	Nagib nagore
+	Slant Down	Nagib nadole
+	Inflate	Naduvavanje
+	Deflate	Izduvavanje
+	Chevron Up	Ševron nagore
+	Chevron Down	Ševron nadole
+	Triangle Up	Trougao nagore
+	Triangle Down	Trougao nadole
+	Solid Accent	Puna boja isticanja
+	Light with Outline	Svetlo sa konturom
+	Hollow	Šuplje
+	Accent Gradient	Gradijent boje isticanja
+	Dark with Shadow	Tamno sa senkom
+	Soft Glow	Meki sjaj
+	Accent with Reflection	Isticanje sa odrazom
+	Warm Gradient with Outline	Topli gradijent sa konturom
+	Add line numbering	Dodaj brojeve redova
+	Add to Document	Dodaj u dokument
+	Address labels	Adresne nalepnice
+	Arabic	Arapski
+	Auto	Automatski
+	Automatically hyphenate document	Automatski deli reči u dokumentu
+	Chinese (Simplified)	Kineski (pojednostavljeni)
+	Chinese (Traditional)	Kineski (tradicionalni)
+	Column:	Kolona:
+	Count by:	Korak:
+	Czech	Češki
+	Danish	Danski
+	Delivery address:	Adresa primaoca:
+	Detect language automatically	Automatski prepoznaj jezik
+	Do not check spelling or grammar	Ne proveravaj pravopis ni gramatiku
+	Dutch	Holandski
+	Envelope size:	Veličina koverte:
+	Estonian	Estonski
+	Finnish	Finski
+	French (France)	Francuski (Francuska)
+	From text:	Od teksta:
+	Full page of the same label	Cela stranica iste nalepnice
+	German (Germany)	Nemački (Nemačka)
+	Greek	Grčki
+	Hebrew	Hebrejski
+	Hyphenate at:	Podeli na:
+	Hyphenate words in CAPS	Deli reči napisane VELIKIM SLOVIMA
+	Hyphenation Options…	Opcije deljenja reči…
+	Hyphenation zone:	Zona deljenja reči:
+	Italian	Italijanski
+	Japanese	Japanski
+	Korean	Korejski
+	Limit consecutive hyphens to:	Najviše uzastopnih crtica:
+	Line Numbering Options…	Opcije brojeva redova…
+	Manual Hyphenation	Ručno deljenje reči
+	Manual hyphenation is complete.	Ručno deljenje reči je završeno.
+	Manual…	Ručno…
+	Mark selected text as:	Označi izabrani tekst kao:
+	New Document	Novi dokument
+	No limit	Bez ograničenja
+	Norwegian (Bokmål)	Norveški (bukmol)
+	Numbering:	Numerisanje:
+	Omit	Izostavi
+	One label per recipient	Jedna nalepnica po primaocu
+	Portuguese (Brazil)	Portugalski (Brazil)
+	Portuguese (Portugal)	Portugalski (Portugalija)
+	Return address labels	Nalepnice sa adresom pošiljaoca
+	Return address:	Adresa pošiljaoca:
+	Row:	Red:
+	Russian	Ruski
+	Serbian (Cyrillic)	Srpski (ćirilica)
+	Serbian (Latin)	Srpski (latinica)
+	Set As Default	Postavi kao podrazumevano
+	Shipping labels	Nalepnice za pošiljke
+	Single label	Jedna nalepnica
+	Spanish (Mexico)	Španski (Meksiko)
+	Spanish (Spain)	Španski (Španija)
+	Swedish	Švedski
+	Turkish	Turski
+	Ukrainian	Ukrajinski
+	{language} is now the document's default language.	{language} je sada podrazumevani jezik dokumenta.
+	Visual effects	Vizuelni efekti
+	Animation effects:	Efekti animacije:
+	On	Uključeno
+	Off	Isključeno
+	Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.	Glatko pomeranje i zumiranje, kao i postepeno pojavljivanje menija i dugmadi. Uz „Isključeno“ svaka promena se prikazuje odmah.
+	Your system has animation effects turned on.	U sistemu su efekti animacije uključeni.
+	Your system has animation effects turned off.	U sistemu su efekti animacije isključeni.
+	Your system doesn't report an animation setting, so animation effects stay on.	Sistem ne prijavljuje podešavanje animacije, pa efekti animacije ostaju uključeni.
diff --git a/crates/ui-egui/src/i18n/sr.tsv b/crates/ui-egui/src/i18n/sr.tsv
index ee5182c617..c891764866 100644
--- a/crates/ui-egui/src/i18n/sr.tsv
+++ b/crates/ui-egui/src/i18n/sr.tsv
@@ -69,12 +69,15 @@
 	Arrow	Стрелица
 	Artistic Effects	Уметнички ефекти
 	As Recommended	Као што је препоручено
+	As you type	Током куцања
+	Asian text font:	Фонт азијског текста:
 	Asian Typography	Азијска типографија
 	Author	Аутор
 	AutoCorrect Options	Опције аутоматске исправке
 	AutoFit	Аутоматско уклапање
 	AutoFit Contents	Аутоматски уклопи према садржају
 	AutoFit Window	Аутоматски уклопи према прозору
+	AutoSave writes your changes to the file a moment after you stop typing.	Аутоматско чување уписује измене у датотеку чим престанете да куцате.
 	Automatic	Аутоматски
 	Automatic ({language})	Аутоматски ({language})
 	Automatic follows your system's language. Menus and commands change; your documents don't.	Аутоматски прати језик система. Менији и наредбе се мењају; документи не.
@@ -85,6 +88,8 @@
 	AutoSave failed: {error}. Save the document to turn AutoSave back on.	Аутоматско чување неуспело: {error}. Сачувајте документ да бисте га поново укључили.
 	Balloons	Облачићи
 	Bottom Margin	Доња маргина
+	Centimeters	Центиметри
+	Check spelling as you type	Проверавај правопис током куцања
 	Click a border between two cells to merge them. Esc stops.	Кликните ивицу између две ћелије да их спојите. Esc завршава.
 	Based on: {style}	Заснован на: {style}
 	Built-in style	Уграђени стил
@@ -96,12 +101,14 @@
 	Character style	Стил знакова
 	Click an item to paste it.	Кликните на ставку да бисте је налепили.
 	Click level to modify:	Кликните ниво који мењате:
+	Click to switch back to inserting	Кликните да бисте се вратили на уметање
 	Clipboard Items	Ставке оставе
 	Clipboard Pane	Окно оставе
 	Color only	Само боја
 	Color: {color}	Боја: {color}
 	Compress punctuation at the start of a line	Сажми интерпункцију на почетку реда
 	Confirm password:	Потврдите лозинку:
+	Custom dictionary	Прилагођени речник
 	Dark page (white text on black)	Тамна страница (бео текст на црном)
 	Drag a rectangle to draw a table, or a line across cells to split them. Esc stops.	Превуците правоугаоник да нацртате табелу или линију преко ћелија да их поделите. Esc завршава.
 	Draw Table	Нацртај табелу
@@ -112,20 +119,52 @@
 	Enter formatting for number:	Облик броја:
 	Follow number with:	После броја:
 	Formatting	Обликовање
+	Formatting marks	Ознаке обликовања
+	Hidden text	Скривени текст
+	Ignore web and file addresses	Занемари веб-адресе и путање датотека
+	Ignore words in capitals	Занемари речи писане великим словима
+	Ignore words with numbers	Занемари речи са бројевима
+	Inches	Инчи
+	Formatting exceptions	Изузеци форматирања
 	Include level number from:	Укључи број нивоа:
+	Initials:	Иницијали:
 	Ink	Мастило
 	Insertions and Deletions	Уметања и брисања
 	Insertions:	Уметања:
+	Interface	Интерфејс
+	Interface language	Језик интерфејса
+	Inside:	Унутра:
+	Latin text font:	Фонт латиничног текста:
 	Left border	Лева ивица
 	Left Margin	Лева маргина
 	Legal style numbering	Правно нумерисање
 	Link level to style:	Повежи ниво са стилом:
 	List Definition	Дефиниција листе
+	Mark grammar errors as you type	Означавај граматичке грешке током куцања
+	Measurement units:	Јединице мере:
+	Millimeters	Милиметри
+	New comments and tracked changes are recorded under this name and these initials.	Нови коментари и праћене измене бележе се под овим именом и иницијалима.
+	New word	Нова реч
+	No words yet. Add to Dictionary on a misspelled word puts it here.	Још нема речи. Додај у речник на погрешно написаној речи ставља је овде.
+	Mirror indents	Пресликај увлачења
 	Nothing	Ништа
 	Number alignment:	Поравнање броја:
 	Number format	Формат броја
 	Number style for this level:	Стил броја за овај ниво:
 	Outside border	Спољна ивица
+	Overtype	Преписивање
+	Overtype (typing replaces the characters after the caret)	Преписивање (откуцано замењује знакове после курсора)
+	Page display	Приказ стране
+	Paragraph marks	Ознаке пасуса
+	Personalize	Персонализација
+	Picas	Пике
+	Points	Тачке
+	Print the page color	Штампај боју стране
+	Printing	Штампање
+	Proofing language	Језик провере писања
+	Recent documents to show:	Број недавних докумената за приказ:
+	Remove	Уклони
+	Outside:	Споља:
 	Reopen	Поново отвори
 	Restart list after:	Поново почни листу после:
 	Right border	Десна ивица
@@ -163,6 +202,7 @@
 	Paste Clipboard Item	Налепи ставку из оставе
 	Preview	Преглед
 	Remove Password	Уклони лозинку
+	Save documents	Чување докумената
 	Shadow, glow and soft edges	Сенка, сјај и меке ивице
 	Shape Effects	Ефекти облика
 	Show all revisions inline	Прикажи све измене у тексту
@@ -171,7 +211,6 @@
 	Distribute spacing	Распореди размак
 	Offset (pt):	Помак (пт):
 	Phonetic Guide	Фонетски водич
-	Remove	Уклони
 	Right (vertical)	Десно (вертикално)
 	Ruby text:	Руби текст:
 	Show documents with their colours inverted, like View › Switch Modes. Saving, printing and PDFs are unchanged.	Прикажи документе са инвертованим бојама, као код Приказ › Промени режим. Чување, штампање и PDF нису погођени.
@@ -199,6 +238,11 @@
 	Border Painter	Копирање ивица
 	Border\nPainter	Копирање\nивица
 	Borders	Ивице
+	Show the mini toolbar when text is selected	Прикажи мини траку са алаткама при избору текста
+	Spaces	Размаци
+	Spelling	Правопис
+	Spelling and grammar are checked in English (United States).	Правопис и граматика се проверавају на енглеском (Сједињене Државе).
+	Tab characters	Знакови табулатора
 	Tab stop position:	Положај табулатора:
 	Default tab stops:	Подразумевани табулатори:
 	Tab stops to be cleared:	Табулатори за брисање:
@@ -209,6 +253,10 @@
 	Set	Постави
 	Page Border	Ивица стране
 	Apply to:	Примени на:
+	These marks show even when Show/Hide ¶ is off.	Ове ознаке се приказују и када је Прикажи/сакриј ¶ искључено.
+	Typing replaces selected text	Откуцано замењује изабрани текст
+	Update fields before printing	Ажурирај поља пре штампања
+	Use the Insert key to switch overtype on and off	Тастер Insert укључује и искључује преписивање
 	Whole document	Цео документ
 	This section	Овај одељак
 	Fill	Испуна
@@ -384,6 +432,7 @@
 	Export PDF	Извези PDF
 	Exported {path}	Извезено: {path}
 	Extend Selection	Прошири избор
+	Extend Selection by Units	Прошири избор по јединицама
 	Field	Поље
 	File	Фајл
 	Find	Пронађи
@@ -791,6 +840,9 @@
 	Show or Hide Style	Прикажи или сакриј стил
 	Show revisions in balloons	Прикажи измене у облачићима
 	Show rulers	Прикажи лењире
+	Animation	Анимација
+	Animate the caret (it glides and fades)	Анимирај курсор (клизи и постепено се гаси)
+	On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off.	Укључено: курсор клизи на ново место док куцате или користите стрелице, а његово трептање се постепено гаси. Искључено: скаче и трепће нагло.
 	Show the community button in the title bar	Прикажи дугме заједнице у траци наслова
 	Show/Hide ¶	Прикажи/сакриј ¶
 	Show\nComments	Прикажи\nкоментаре
@@ -943,10 +995,10 @@
 	Wide	Широко
 	Widow/Orphan Control	Контрола усамљених редова
 	Widow/Orphan control	Контрола усамљених редова
-	Wildcards (regex)	Џокер знаци (regex)
 	Window	Прозор
 	Word Count	Број речи
 	Word document (*.docx)	Word документ (*.docx)
+	Word XML Document (*.xml)	Word XML документ (*.xml)
 	Word Left	Реч лево
 	Word Right	Реч десно
 	WordArt	WordArt
@@ -1362,8 +1414,86 @@
 	Selected Fields	Изабрана поља
 	Edit Field…	Уреди поље…
 	Formatted	Форматирано
+	Deleted	Избрисано
 	Interface size:	Величина интерфејса:
 	Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate.	Повећава или смањује траку, меније и дијалоге, поврх скалирања екрана у систему. Зумирање документа је засебно.
+	Resize Table by Dragging	Промена величине табеле превлачењем
+	Print Markup	Штампај ознаке
+	Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text.	Коментари поред сваке странице и праћене измене у PDF-овима, отисцима и сликама; листа коментара на крају веб-страница, Markdown-а и текста.
+
+# Compare / Combine, AutoCorrect Options and Restrict Editing (#412)
+	1. Formatting restrictions	1. Ограничења обликовања
+	2. Editing restrictions	2. Ограничења уређивања
+	3. Start enforcement	3. Покретање заштите
+	<< Less	<< Мање
+	Another file	Друга датотека
+	Apply as you type	Примени док куцаш
+	AutoCorrect	Аутоматска исправка
+	AutoFormat As You Type	Аутоматско обликовање током куцања
+	Automatic bulleted lists	Аутоматске листе са знаковима
+	Automatic numbered lists	Аутоматске нумерисане листе
+	Border lines	Линије ивица
+	Capitalize first letter of sentences	Велико прво слово реченице
+	Capitalize first letter of table cells	Велико прво слово у ћелијама табеле
+	Capitalize names of days	Велико слово у називима дана
+	Case changes	Промене величине слова
+	Character level	Ниво знака
+	Checked styles are allowed:	Означени стилови су дозвољени:
+	Combine Documents	Спајање докумената
+	Compare Documents	Упоређивање докумената
+	Compared: {changes} changes	Упоређено: измена {changes}
+	Comparing with another file needs the desktop app.	За поређење са другом датотеком потребна је десктоп апликација.
+	Comparison settings	Подешавања поређења
+	Don't capitalize after:	Без великог слова после:
+	Editing in this document is restricted.	Уређивање овог документа је ограничено.
+	Every change is recorded as a tracked change.	Свака измена се бележи као праћена измена.
+	Everyone	Сви
+	Exceptions (optional)	Изузеци (необавезно)
+	Exceptions…	Изузеци…
+	Fields	Поља
+	Filling in forms	Попуњавање образаца
+	Find Next Editable Region	Пронађи следећи део за уређивање
+	Footnotes and endnotes	Фусноте и крајње напомене
+	Formatting, case changes, white space and tables are compared; the other settings are kept for later.	Пореде се обликовање, величина слова, размаци и табеле; остала подешавања се чувају за касније.
+	Fractions (1/2) as fraction characters (½)	Разломци (1/2) као знакови разломка (½)
+	Headers and footers	Заглавља и подножја
+	Hyphens (--) as dashes (—)	Цртице (--) као црте (—)
+	In equations, typing a name after a backslash replaces it with its symbol.	У једначинама се назив откуцан после обрнуте косе црте замењује симболом.
+	Internet addresses as links	Интернет адресе као везе
+	Label changes with:	Означи измене са:
+	Limit formatting to a selection of styles	Ограничи обликовање на изабране стилове
+	Math AutoCorrect	Аутоматска исправка математике
+	More >>	Више >>
+	Moves	Премештања
+	New document	Нови документ
+	No changes (read only)	Без измена (само за читање)
+	Only allow this kind of editing:	Дозволи само ову врсту уређивања:
+	Only comments can be added, except in regions marked editable.	Могу се додавати само коментари, осим у деловима означеним за уређивање.
+	Only form fields can be filled in.	Могу се попунити само поља обрасца.
+	Only the allowed styles can be applied.	Могу се применити само дозвољени стилови.
+	Ordinals (1st) as superscript	Редни бројеви (1st) као експонент
+	Original document	Оригинални документ
+	This password type isn't supported.	Ова врста лозинке није подржана.
+	Replace as you type	Замени док куцаш
+	Replace text as you type	Замени текст док куцаш
+	Replace:	Замени:
+	Revised document	Измењени документ
+	Select text, then tick who can still edit it.	Изаберите текст, па означите ко још може да га уређује.
+	Settings…	Подешавања…
+	Show changes at:	Прикажи измене на нивоу:
+	Show changes in:	Прикажи измене у:
+	Smart quotes instead of straight quotes	Типографски наводници уместо правих
+	Start Enforcing Protection	Покрени заштиту
+	Stop Protection	Заустави заштиту
+	Text boxes	Оквири за текст
+	The document is read only, except for regions marked editable.	Документ је само за читање, осим делова означених за уређивање.
+	The password is optional; without it anyone can stop the protection.	Лозинка није обавезна; без ње свако може да заустави заштиту.
+	This document	Овај документ
+	Tracked changes	Праћене измене
+	Type the password to stop the protection.	Унесите лозинку да бисте зауставили заштиту.
+	White space	Размаци
+	With:	Са:
+	Word level	Ниво речи
 	In Line with Text	У равни са текстом
 	Square	Квадратно
 	Through	Кроз
@@ -1410,6 +1540,36 @@
 	New Group	Нова група
 	Rename…	Преименуј…
 	Ribbon and Quick Access Toolbar:	Трака и трака са алаткама за брзи приступ:
+	Add Font…	Додај фонт…
+	Added Fonts	Додати фонтови
+	Remove Added Font	Уклони додати фонт
+	Recent Colors	Недавне боје
+	More Colors…	Још боја…
+	Standard	Стандардне
+	Current	Тренутна
+	Colors:	Боје:
+	Color model:	Модел боја:
+	Red:	Црвена:
+	Green:	Зелена:
+	Blue:	Плава:
+	Hue:	Нијанса:
+	Sat:	Засићеност:
+	Lum:	Осветљеност:
+	Hex:	Хекс:
+	Accessibility Pane	Окно приступачности
+	Alt Text Pane	Окно алтернативног текста
+	Alt\nText	Алтернативни\nтекст
+	View Alt Text…	Прикажи алтернативни текст…
+	Mark as decorative	Означи као декоративно
+	Title:	Наслов:
+	Errors ({n})	Грешке ({n})
+	Warnings ({n})	Упозорења ({n})
+	Tips ({n})	Савети ({n})
+	No accessibility issues found.	Није пронађен ниједан проблем приступачности.
+	Describe what this object shows, for people who can't see it.	Опишите шта овај објекат приказује, за оне који не могу да га виде.
+	Decorative objects only add visual interest: screen readers skip them.	Декоративни објекти само доприносе изгледу: читачи екрана их прескачу.
+	Describe what this table shows, for people who can't see it.	Опишите шта ова табела приказује, за оне који не могу да је виде.
+	Select a picture, shape, chart or table to describe it.	Изаберите слику, облик, графикон или табелу да бисте их описали.
 	Document Grid	Мрежа документа
 	No grid	Без мреже
 	Lines only	Само редови
@@ -1419,6 +1579,39 @@
 	Lines per page:	Редова по страници:
 	Moved from	Премештено одавде
 	Moved to	Премештено овде
+	Developer	Програмер
+	Controls	Контроле
+	Rich Text Content Control	Контрола садржаја за обогаћени текст
+	Plain Text Content Control	Контрола садржаја за обичан текст
+	Picture Content Control	Контрола садржаја за слику
+	Building Block Gallery Content Control	Контрола садржаја за галерију градивних блокова
+	Check Box Content Control	Контрола садржаја за поље за потврду
+	Combo Box Content Control	Контрола садржаја за комбиновано поље
+	Drop-Down List Content Control	Контрола садржаја за падајућу листу
+	Date Picker Content Control	Контрола садржаја за бирање датума
+	Repeating Section Content Control	Контрола садржаја за одељак који се понавља
+	Design Mode	Режим дизајна
+	Content Control at Selection	Контрола садржаја на избору
+	Toggle Check Box	Промени поље за потврду
+	Choose List Item	Изабери ставку листе
+	Set Date	Постави датум
+	Remove Content Control	Уклони контролу садржаја
+	Content Control Properties	Својства контроле садржаја
+	Title	Наслов
+	Tag	Ознака
+	Placeholder text	Текст чувара места
+	Can't be deleted	Не може да се избрише
+	Contents can't be edited	Садржај не може да се уређује
+	Remove the control once edited	Уклони контролу после уређивања
+	Allow line breaks	Дозволи преломе реда
+	Date format	Формат датума
+	Checked symbol	Симбол за потврђено
+	Unchecked symbol	Симбол за непотврђено
+	List entries	Ставке листе
+	Display text	Приказани текст
+	Value	Вредност
+	Today	Данас
+	Put the caret in a content control first.	Прво поставите курсор у контролу садржаја.
 	Right-to-Left Table	Табела са десна на лево
 	Right-to-Left Section	Одељак са десна на лево
 	Table direction:	Смер табеле:
@@ -1446,6 +1639,50 @@
 	Enlarge symbol	Увећај симбол
 	Enclosure	Оквир
 	Circle	Круг
+	Templates	Шаблони
+	Templates and Add-ins	Шаблони и додаци
+	Attach Template	Приложи шаблон
+	Detach Template	Уклони шаблон
+	Automatically Update Document Styles	Аутоматски ажурирај стилове документа
+	Update Styles from Template	Ажурирај стилове из шаблона
+	Organizer	Организатор
+	Copy Styles	Копирај стилове
+	Rename Style	Преименуј стил
+	Document template:	Шаблон документа:
+	Attach…	Приложи…
+	Automatically update document styles	Аутоматски ажурирај стилове документа
+	Organizer…	Организатор…
+	Change Chart Type	Промени тип графикона
+	Chart Design	Дизајн графикона
+	Type	Тип
+	Edit Data	Уреди податке
+	Chart Title	Наслов графикона
+	Chart Layouts	Распореди графикона
+	Add Chart Element	Додај елемент графикона
+	Legend	Легенда
+	Data Labels	Ознаке података
+	Above Chart	Изнад графикона
+	Insert Chart	Уметни графикон
+	Clustered Column	Груписане колоне
+	Stacked Column	Наслагане колоне
+	Clustered Bar	Груписане траке
+	Stacked Bar	Наслагане траке
+	Area	Површински
+	Pie	Кружни
+	Doughnut	Прстенасти
+	Scatter	Распршени
+	“{text}” ({row}, {series}) isn't a number.	„{text}” ({row}, {series}) није број.
+	Category {n}	Категорија {n}
+	Series {n}	Серија {n}
+	Type the categories down the side and a column of values per series.	Унесите категорије са стране и по једну колону вредности за сваку серију.
+	Categories	Категорије
+	Series name	Назив серије
+	Remove series	Уклони серију
+	Remove row	Уклони ред
+	Add Row	Додај ред
+	Add Series	Додај серију
+	Edit\nData	Уреди\nподатке
+	Change\nChart Type	Промени тип\nграфикона
 	Align Text	Поравнај текст
 	Create Link	Направи везу
 	Break Link	Прекини везу
@@ -1470,3 +1707,346 @@
 	English (United Kingdom)	Енглески (Велика Британија)
 	Polish	Пољски
 	Do Not Check Spelling or Grammar	Не проверавај правопис и граматику
+
+# Built-in file browser when the system file dialog is unavailable (#576)
+	Documents	Документи
+	Word document	Word документ
+	All files	Све датотеке
+	Recipient lists	Листе прималаца
+	The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity.	Системски дијалог за датотеке није доступан, па WordCraft приказује свој. Да бисте добили системски дијалог, инсталирајте портал за избор датотека (на пример xdg-desktop-portal-gtk) или zenity.
+	Up one level	Један ниво горе
+	Home folder	Лична фасцикла
+	{name} wasn't found.	{name} није пронађен.
+	{name} already exists. Choose Save again to replace it.	{name} већ постоји. Изаберите Сачувај поново да бисте заменили датотеку.
+	This folder can't be read: {error}	Ова фасцикла не може да се прочита: {error}
+	Showing the first {count} items.	Приказане су само прве ставке: {count}.
+	File name:	Име датотеке:
+	Browse in WordCraft…	Потражи у WordCraft-у…
+	Open a file with WordCraft's own browser when the system file dialog doesn't appear.	Отворите датотеку помоћу WordCraft-овог прегледача када се системски дијалог за датотеке не појави.
+	Hide White Space	Сакриј празан простор
+	All pages	Све странице
+	Current page	Тренутна страница
+	Selected pages	Изабране странице
+	Custom range	Прилагођени опсег
+	All pages in the range	Све странице у опсегу
+	Odd pages only	Само непарне странице
+	Even pages only	Само парне странице
+	Copies	Копије
+	Collate copies	Сложи копије
+	Pages like 1-3, 5	Странице попут 1-3, 5
+	{count} of {total} pages will print	Штампаће се {count} од {total} страница
+	Save these pages as PDF…	Сачувај ове странице као PDF…
+	The printer, two-sided printing and pages per sheet are chosen in that dialog.	Штампач, обострана штампа и број страница по листу бирају се у том дијалогу.
+	Previous Page	Претходна страница
+	Print to PDF	Штампај у PDF
+	Add Shape	Додај облик
+	Change Colors	Промени боје
+	Change Layout	Промени распоред
+	Create Graphic	Креирање графике
+	Edit Items	Уреди ставке
+	Layouts	Распореди
+	Reset Graphic	Ресетуј графику
+	SmartArt Design	SmartArt дизајн
+	SmartArt Styles	SmartArt стилови
+	Text Pane	Окно за текст
+	List	Листа
+	Process	Процес
+	Cycle	Циклус
+	Hierarchy	Хијерархија
+	Relationship	Однос
+	Pyramid	Пирамида
+	Basic List	Основна листа
+	Basic Process	Основни процес
+	Basic Cycle	Основни циклус
+	Basic Pyramid	Основна пирамида
+	Basic Radial	Основни радијални
+	Basic Matrix	Основна матрица
+	Basic Venn	Основни Венов дијаграм
+	Shows items of equal weight as blocks in rows.	Приказује ставке једнаке важности као блокове у редовима.
+	Shows steps in order, left to right, with arrows between them.	Приказује кораке редом, слева надесно, са стрелицама између њих.
+	Shows steps that repeat, around a circle.	Приказује кораке који се понављају, око круга.
+	Shows a tree: each item below the item it belongs to.	Приказује стабло: свака ставка испод ставке којој припада.
+	Shows parts that build on each other, largest at the bottom.	Приказује делове који се ослањају један на други, највећи на дну.
+	Shows items around a central idea: the first item is the centre.	Приказује ставке око централне идеје: прва ставка је у средини.
+	Shows parts of a whole as quadrants.	Приказује делове целине као квадранте.
+	Shows overlapping ideas as overlapping circles.	Приказује идеје које се преклапају као кругове који се преклапају.
+	Accent {n}	Акценат {n}
+	Colorful	Шарено
+	Insert SmartArt	Уметни SmartArt
+	One line per item. Enter adds an item.	Један ред по ставци. Enter додаје ставку.
+	Add\nShape	Додај\nоблик
+	Change\nColors	Промени\nбоје
+	Reset\nGraphic	Ресетуј\nграфику
+	Promote to Heading 1	Подигни на Наслов 1
+	Demote to Body Text	Спусти на основни текст
+	Move Up	Помери нагоре
+	Move Down	Помери надоле
+	Collapse	Скупи
+	Expand or Collapse Heading	Прошири или скупи наслов
+	Select Heading and Content	Изабери наслов и садржај
+	Show Level	Прикажи ниво
+	Show Level 1	Прикажи ниво 1
+	Show Level 2	Прикажи ниво 2
+	Show Level 3	Прикажи ниво 3
+	Show Level 4	Прикажи ниво 4
+	Show Level 5	Прикажи ниво 5
+	Show Level 6	Прикажи ниво 6
+	Show Level 7	Прикажи ниво 7
+	Show Level 8	Прикажи ниво 8
+	Show Level 9	Прикажи ниво 9
+	Show All Levels	Прикажи све нивое
+	All Levels	Сви нивои
+	Show First Line Only	Прикажи само први ред
+	Show Text Formatting	Прикажи обликовање текста
+	Close Outline View	Затвори приказ контуре
+	Outline State	Стање контуре
+	Outlining	Контура
+	Outline Tools	Алатке контуре
+	Close Outline\nView	Затвори приказ\nконтуре
+	A, B, C, …	A, B, C, …
+	Above the item	Изнад ставке
+	Accessed on	Приступљено
+	Add New Source…	Додај нови извор…
+	Add the chapter number	Додај број поглавља
+	Atmosphere	Атмосфера
+	Below the item	Испод ставке
+	Book	Књига
+	Book title	Наслов књиге
+	Caption	Натпис
+	Caption Numbering	Нумерисање натписа
+	Caption text	Текст натписа
+	Caption:	Натпис:
+	Chapter in a book	Поглавље у књизи
+	Chapters begin at:	Поглавља почињу на:
+	Collect entries from:	Ставке узети из:
+	Columns:	Колоне:
+	Conference	Конференција
+	Conference paper	Рад са конференције
+	Container Title	Наслов збирке
+	Create Source	Направи извор
+	Cross-reference:	Унакрсна референца:
+	Custom Table of Contents…	Прилагођени садржај…
+	DOI	DOI
+	Day	Дан
+	Delete Label	Обриши ознаку
+	Edit Source	Уреди извор
+	Edition	Издање
+	Edit…	Уреди…
+	Entry marked.	Ставка је означена.
+	Example: {sample}	Пример: {sample}
+	Figure	Слика
+	Film	Филм
+	Heading styles (levels 1–{n})	Стилови наслова (нивои 1–{n})
+	Heading {n}	Наслов {n}
+	I, II, III, …	I, II, III, …
+	Include page numbers	Укључи бројеве страница
+	Indented	Увучено
+	Institution	Институција
+	Ionosphere	Јоносфера
+	Issue	Број
+	Journal	Часопис
+	Label:	Ознака:
+	Last, First; Last, First	Презиме, Име; Презиме, Име
+	Leave the label out of the caption	Изостави ознаку из натписа
+	Letter headings	Наслови по словима
+	Levels:	Нивои:
+	Link entries to their headings	Повежи ставке са насловима
+	Made from the author and year when empty	Ако је празно, прави се од аутора и године
+	Magazine or newspaper article	Чланак у магазину или новинама
+	Main entry:	Главна ставка:
+	Mark	Означи
+	Mark All	Означи све
+	Mark Entry…	Означи ставку…
+	Mark Index Entry	Означи ставку индекса
+	Mesosphere	Мезосфера
+	Month	Месец
+	New Label	Нова ознака
+	New Label…	Нова ознака…
+	New…	Ново…
+	No sources yet.	Још нема извора.
+	Numbering…	Нумерисање…
+	Options…	Опције…
+	Other	Друго
+	Other styles and their TOC level:	Остали стилови и њихов ниво у садржају:
+	Outline levels	Нивои структуре
+	Page number style	Стил броја странице
+	Page numbers at the right margin	Бројеви страница уз десну маргину
+	Page title	Наслов странице
+	Pages of bookmark:	Странице обележивача:
+	Periodical	Периодика
+	Position:	Положај:
+	Publisher	Издавач
+	Run-in	У низу
+	See	Види
+	Separator:	Раздвајач:
+	Show every bibliography field	Прикажи сва поља библиографије
+	Site name	Назив сајта
+	Source Manager	Управљач изворима
+	Source type:	Врста извора:
+	Sources in this document:	Извори у овом документу:
+	Styles:	Стилови:
+	Subentry:	Подставка:
+	TC entry fields	Поља ставки TC
+	Tab leader:	Попуна табулатора:
+	Table of Contents Options	Опције садржаја
+	Table of Contents Styles	Стилови садржаја
+	This page	Ова страница
+	Type:	Врста:
+	URL	URL
+	Volume	Том
+	Website	Веб-сајт
+	Year	Година
+	a, b, c, …	a, b, c, …
+	i, ii, iii, …	i, ii, iii, …
+	{n} entries marked.	Означено ставки: {n}.
+	Lasso Select	Избор ласом
+	Move Selected Ink	Премести изабрани рукопис
+	Delete Selected Ink	Обриши изабрани рукопис
+	Recolor Selected Ink	Промени боју изабраног рукописа
+	Add Pen	Додај перо
+	Remove Pen	Уклони перо
+	Ink to Shape	Рукопис у облик
+	Convert to Shapes	Претвори у облике
+	Ink Replay	Рукопис реприза
+	Add\nPen	Додај\nперо
+	Rewind	На почетак
+	Forward	Напред
+	Stroke {n} of {total}	Потез {n} од {total}
+	Use wildcards	Користи џокер знаке
+	Special	Посебно
+	Match prefix	Подудари префикс
+	Match suffix	Подудари суфикс
+	Ignore punctuation characters	Занемари знаке интерпункције
+	Ignore white-space characters	Занемари белине
+	Regular expressions	Регуларни изрази
+	Search Options	Опције претраге
+	Tab Character	Знак табулатора
+	Any Character	Било који знак
+	Any Digit	Било која цифра
+	Any Letter	Било које слово
+	Caret Character	Знак капице
+	Section Character	Знак одељка
+	Paragraph Character	Симбол пасуса
+	Graphic	Графика
+	Manual Line Break	Ручни прекид реда
+	Manual Page Break	Ручни прекид стране
+	Section Break	Прекид одељка
+	White Space	Белина
+	Clipboard Contents	Садржај оставе
+	Find What Text	Пронађени текст
+	Find What Expression	Пронађени израз
+	Character in Range	Знак у опсегу
+	Beginning of Word	Почетак речи
+	End of Word	Крај речи
+	Expression	Израз
+	Not	Није
+	Num Occurrences	Број понављања
+	Previous 1 or More	Претходно 1 или више пута
+	0 or More Characters	0 или више знакова
+	Move with Text	Померај са текстом
+	Fix Position on Page	Фиксирај положај на страници
+
+# WordArt and connectors (#416).
+	WordArt Styles	WordArt стилови
+	Text Fill	Попуна текста
+	Text Outline	Контура текста
+	Transform	Трансформација
+	No Fill	Без попуне
+	No Outline	Без контуре
+	Reflection	Одраз
+	No Reflection	Без одраза
+	No Transform	Без трансформације
+	Connect Shapes	Повежи облике
+	Straight Connector	Прави конектор
+	Straight Arrow Connector	Прави конектор са стрелицом
+	Elbow Connector	Угаони конектор
+	Elbow Arrow Connector	Угаони конектор са стрелицом
+	Curved Connector	Закривљени конектор
+	Curved Arrow Connector	Закривљени конектор са стрелицом
+	Arch Up	Лук нагоре
+	Arch Down	Лук надоле
+	Slant Up	Нагиб нагоре
+	Slant Down	Нагиб надоле
+	Inflate	Надувавање
+	Deflate	Издувавање
+	Chevron Up	Шеврон нагоре
+	Chevron Down	Шеврон надоле
+	Triangle Up	Троугао нагоре
+	Triangle Down	Троугао надоле
+	Solid Accent	Пуна боја истицања
+	Light with Outline	Светло са контуром
+	Hollow	Шупље
+	Accent Gradient	Градијент боје истицања
+	Dark with Shadow	Тамно са сенком
+	Soft Glow	Меки сјај
+	Accent with Reflection	Истицање са одразом
+	Warm Gradient with Outline	Топли градијент са контуром
+	Add line numbering	Додај бројеве редова
+	Add to Document	Додај у документ
+	Address labels	Адресне налепнице
+	Arabic	Арапски
+	Auto	Аутоматски
+	Automatically hyphenate document	Аутоматски дели речи у документу
+	Chinese (Simplified)	Кинески (поједностављени)
+	Chinese (Traditional)	Кинески (традиционални)
+	Column:	Колона:
+	Count by:	Корак:
+	Czech	Чешки
+	Danish	Дански
+	Delivery address:	Адреса примаоца:
+	Detect language automatically	Аутоматски препознај језик
+	Do not check spelling or grammar	Не проверавај правопис ни граматику
+	Dutch	Холандски
+	Envelope size:	Величина коверте:
+	Estonian	Естонски
+	Finnish	Фински
+	French (France)	Француски (Француска)
+	From text:	Од текста:
+	Full page of the same label	Цела страница исте налепнице
+	German (Germany)	Немачки (Немачка)
+	Greek	Грчки
+	Hebrew	Хебрејски
+	Hyphenate at:	Подели на:
+	Hyphenate words in CAPS	Дели речи написане ВЕЛИКИМ СЛОВИМА
+	Hyphenation Options…	Опције дељења речи…
+	Hyphenation zone:	Зона дељења речи:
+	Italian	Италијански
+	Japanese	Јапански
+	Korean	Корејски
+	Limit consecutive hyphens to:	Највише узастопних цртица:
+	Line Numbering Options…	Опције бројева редова…
+	Manual Hyphenation	Ручно дељење речи
+	Manual hyphenation is complete.	Ручно дељење речи је завршено.
+	Manual…	Ручно…
+	Mark selected text as:	Означи изабрани текст као:
+	New Document	Нови документ
+	No limit	Без ограничења
+	Norwegian (Bokmål)	Норвешки (букмол)
+	Numbering:	Нумерисање:
+	Omit	Изостави
+	One label per recipient	Једна налепница по примаоцу
+	Portuguese (Brazil)	Португалски (Бразил)
+	Portuguese (Portugal)	Португалски (Португалија)
+	Return address labels	Налепнице са адресом пошиљаоца
+	Return address:	Адреса пошиљаоца:
+	Row:	Ред:
+	Russian	Руски
+	Serbian (Cyrillic)	Српски (ћирилица)
+	Serbian (Latin)	Српски (латиница)
+	Set As Default	Постави као подразумевано
+	Shipping labels	Налепнице за пошиљке
+	Single label	Једна налепница
+	Spanish (Mexico)	Шпански (Мексико)
+	Spanish (Spain)	Шпански (Шпанија)
+	Swedish	Шведски
+	Turkish	Турски
+	Ukrainian	Украјински
+	{language} is now the document's default language.	{language} је сада подразумевани језик документа.
+	Visual effects	Визуелни ефекти
+	Animation effects:	Ефекти анимације:
+	On	Укључено
+	Off	Искључено
+	Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.	Глатко померање и зумирање, као и постепено појављивање менија и дугмади. Уз „Искључено“ свака промена се приказује одмах.
+	Your system has animation effects turned on.	У систему су ефекти анимације укључени.
+	Your system has animation effects turned off.	У систему су ефекти анимације искључени.
+	Your system doesn't report an animation setting, so animation effects stay on.	Систем не пријављује подешавање анимације, па ефекти анимације остају укључени.
diff --git a/crates/ui-egui/src/i18n/tests.rs b/crates/ui-egui/src/i18n/tests.rs
index da40093ec2..44dcafffd9 100644
--- a/crates/ui-egui/src/i18n/tests.rs
+++ b/crates/ui-egui/src/i18n/tests.rs
@@ -349,12 +349,44 @@ fn chinese_interface_fonts_load_and_cover_simplified_hanzi() {
     ctx.set_fonts(crate::theme::font_definitions(true, true));
     ctx.run_ui(Default::default(), |_| {}).textures_delta.clear();
     let covered = ctx.fonts_mut(|f| f.has_glyphs(&egui::FontId::proportional(14.0), "删除页选"));
-    let embedded = !wordcraft_fonts::ui_needs_system_cjk(true, &wordcraft_fonts::ui_cjk_fonts(true));
-    if embedded || wordcraft_fonts::system_cjk_ui_font(true).is_some() {
+    let (catalogs, _) = Lang::cjk_font_text(true);
+    let embedded = !wordcraft_fonts::ui_needs_system_cjk(&catalogs, &wordcraft_fonts::ui_cjk_fonts(true));
+    if embedded || wordcraft_fonts::system_cjk_ui_font(true, &['页']).is_some() {
         assert!(covered, "a Chinese face is available but the interface lacks simplified hanzi");
     }
 }
 
+#[test]
+fn cjk_catalogs_are_covered_by_the_embedded_interface_faces() {
+    // #486: every CJK character of the Chinese and Japanese catalogs and of the language names
+    // has a glyph in the interface font chain built from the embedded faces alone, in every
+    // interface weight; `?` and boxes showed where the Japanese face was the only CJK one. Needs
+    // a craft-fonts build (CRAFT_FONTS_DIR); without one there is nothing embedded to check, and
+    // the interface reads an installed CJK font instead.
+    if wordcraft_fonts::ui_cjk_fonts(false).is_empty() {
+        eprintln!("skipped: built without craft-fonts (CRAFT_FONTS_DIR)");
+        return;
+    }
+    let names: String = Lang::all().map(Lang::name).collect();
+    for code in ["zh-hans", "zh-hant", "ja"] {
+        let l = lang(code);
+        let ctx = egui::Context::default();
+        ctx.set_fonts(crate::theme::font_definitions(l.prefers_hans(), false));
+        ctx.run_ui(Default::default(), |_| {}).textures_delta.clear();
+        let (entries, errors) = parse_entries(l.0.source);
+        assert!(errors.is_empty(), "{code}: {errors:?}");
+        let chars: std::collections::BTreeSet<char> =
+            entries.iter().flat_map(|e| e.translation.chars()).chain(names.chars()).filter(|c| wordcraft_fonts::is_cjk(*c)).collect();
+        assert!(chars.len() > 300, "{code}: {} CJK characters", chars.len());
+        for font in [crate::theme::regular(14.0), crate::theme::medium(14.0), crate::theme::semibold(14.0)] {
+            let missing: String = ctx.fonts_mut(|f| chars.iter().filter(|c| !f.has_glyph(&font, **c)).collect());
+            assert!(missing.is_empty(), "{code}: no glyph in {font:?} for {missing}");
+        }
+        // So the interface reads no installed CJK font for these languages.
+        assert_eq!(wordcraft_fonts::ui_uncovered_cjk(&[l.0.source, &names], &wordcraft_fonts::ui_cjk_fonts(l.prefers_hans())), []);
+    }
+}
+
 #[test]
 fn only_cjk_languages_ask_for_an_installed_cjk_font() {
     // #241 follow-up: an English interface must not read a large system CJK font on startup.
diff --git a/crates/ui-egui/src/i18n/tr.tsv b/crates/ui-egui/src/i18n/tr.tsv
index 53562fc484..26f0d4349f 100644
--- a/crates/ui-egui/src/i18n/tr.tsv
+++ b/crates/ui-egui/src/i18n/tr.tsv
@@ -252,6 +252,7 @@
 	Export a copy to share (PDF, Word document)	Paylaşmak için bir kopya dışa aktarın (PDF, Word belgesi)
 	Exported {path}	Dışa aktarıldı: {path}
 	Extend Selection	Seçimi Genişlet
+	Extend Selection by Units	Seçimi Birimlere Göre Genişlet
 	Field	Alan
 	File	Dosya
 	Find	Bul
@@ -662,6 +663,9 @@
 	Show Notes	Notları Göster
 	Show all formatting marks	Tüm biçimlendirme işaretlerini göster
 	Show rulers	Cetvelleri göster
+	Animate the caret (it glides and fades)	İmleci canlandır (kayarak ilerler ve solarak yanıp söner)
+	Animation	Animasyon
+	On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off.	Açık: yazarken veya ok tuşlarını kullanırken imleç yeni yerine kayarak gider ve yanıp sönerken solar. Kapalı: imleç yeni yerine atlar, keskin biçimde yanıp söner.
 	Show the community button in the title bar	Başlık çubuğunda topluluk düğmesini göster
 	Show/Hide ¶	Göster/Gizle ¶
 	Show\nComments	Yorumları\nGöster
@@ -798,7 +802,6 @@
 	Wide	Geniş
 	Widow/Orphan Control	Tek Kalan Satır Denetimi
 	Widow/Orphan control	Tek kalan satır denetimi
-	Wildcards (regex)	Joker karakterler (regex)
 	Window	Pencere
 	Word Count	Sözcük Sayısı
 	Word Left	Önceki Sözcük
@@ -1322,6 +1325,7 @@
 	Flip Vertical	Dikey Çevir
 	Flip Horizontal	Yatay Çevir
 	Formatted	Biçimlendirildi
+	Deleted	Silindi
 	Copyright Sign	Telif Hakkı İşareti
 	Demote	Düzey Düşür
 	Edit Field Code	Alan Kodunu Düzenle
@@ -1411,6 +1415,39 @@
 	Left Only	Yalnızca Sol
 	Right Only	Yalnızca Sağ
 	Largest Only	Yalnızca En Geniş
+	Resize Table by Dragging	Tabloyu Sürükleyerek Yeniden Boyutlandır
+	Add Font…	Yazı Tipi Ekle…
+	Added Fonts	Eklenen Yazı Tipleri
+	Remove Added Font	Eklenen Yazı Tipini Kaldır
+	Print Markup	İşaretlemeyi Yazdır
+	Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text.	PDF'lerde, baskılarda ve görüntülerde her sayfanın yanında açıklamalar ve izlenen değişiklikler; web sayfalarının, Markdown ve metnin sonunda açıklama listesi.
+	Recent Colors	Son Kullanılan Renkler
+	More Colors…	Diğer Renkler…
+	Standard	Standart
+	Current	Geçerli
+	Colors:	Renkler:
+	Color model:	Renk modeli:
+	Red:	Kırmızı:
+	Green:	Yeşil:
+	Blue:	Mavi:
+	Hue:	Ton:
+	Sat:	Doygunluk:
+	Lum:	Parlaklık:
+	Hex:	Onaltılık:
+	Accessibility Pane	Erişilebilirlik Bölmesi
+	Alt Text Pane	Alternatif Metin Bölmesi
+	Alt\nText	Alternatif\nMetin
+	View Alt Text…	Alternatif Metni Görüntüle…
+	Mark as decorative	Dekoratif olarak işaretle
+	Title:	Başlık:
+	Errors ({n})	Hatalar ({n})
+	Warnings ({n})	Uyarılar ({n})
+	Tips ({n})	İpuçları ({n})
+	No accessibility issues found.	Erişilebilirlik sorunu bulunamadı.
+	Describe what this object shows, for people who can't see it.	Bu nesnenin neyi gösterdiğini, göremeyenler için açıklayın.
+	Decorative objects only add visual interest: screen readers skip them.	Dekoratif nesneler yalnızca görsel çekicilik katar: ekran okuyucular bunları atlar.
+	Describe what this table shows, for people who can't see it.	Bu tablonun neyi gösterdiğini, göremeyenler için açıklayın.
+	Select a picture, shape, chart or table to describe it.	Açıklamak için bir resim, şekil, grafik veya tablo seçin.
 	Document Grid	Belge Kılavuzu
 	No grid	Kılavuz yok
 	Lines only	Yalnızca satırlar
@@ -1420,10 +1457,152 @@
 	Lines per page:	Sayfa başına satır:
 	Moved from	Taşındı (kaynak)
 	Moved to	Taşındı (hedef)
+	Developer	Geliştirici
+	Controls	Denetimler
+	Rich Text Content Control	Zengin Metin İçerik Denetimi
+	Plain Text Content Control	Düz Metin İçerik Denetimi
+	Picture Content Control	Resim İçerik Denetimi
+	Building Block Gallery Content Control	Yapı Bloğu Galerisi İçerik Denetimi
+	Check Box Content Control	Onay Kutusu İçerik Denetimi
+	Combo Box Content Control	Açılan Kutu İçerik Denetimi
+	Drop-Down List Content Control	Açılır Liste İçerik Denetimi
+	Date Picker Content Control	Tarih Seçici İçerik Denetimi
+	Repeating Section Content Control	Yinelenen Bölüm İçerik Denetimi
+	Design Mode	Tasarım Modu
+	Content Control at Selection	Seçimdeki İçerik Denetimi
+	Toggle Check Box	Onay Kutusunu Değiştir
+	Choose List Item	Liste Öğesi Seç
+	Set Date	Tarihi Ayarla
+	Remove Content Control	İçerik Denetimini Kaldır
+	Content Control Properties	İçerik Denetimi Özellikleri
+	Title	Başlık
+	Tag	Etiket
+	Placeholder text	Yer tutucu metin
+	Can't be deleted	Silinemez
+	Contents can't be edited	İçerik düzenlenemez
+	Remove the control once edited	Düzenlendikten sonra denetimi kaldır
+	Allow line breaks	Satır sonlarına izin ver
+	Date format	Tarih biçimi
+	Checked symbol	Seçili simge
+	Unchecked symbol	Seçili olmayan simge
+	List entries	Liste girdileri
+	Display text	Görünen metin
+	Value	Değer
+	Today	Bugün
+	Put the caret in a content control first.	Önce imleci bir içerik denetiminin içine koyun.
 	Right-to-Left Table	Sağdan Sola Tablo
 	Right-to-Left Section	Sağdan Sola Bölüm
 	Table direction:	Tablo yönü:
 	Section direction:	Bölüm yönü:
+	A, B, C, …	A, B, C, …
+	Above the item	Öğenin üstünde
+	Accessed on	Erişim tarihi
+	Add New Source…	Yeni Kaynak Ekle…
+	Add the chapter number	Bölüm numarasını ekle
+	Atmosphere	Atmosfer
+	Below the item	Öğenin altında
+	Book	Kitap
+	Book title	Kitap başlığı
+	Caption	Başlık
+	Caption Numbering	Başlık Numaralandırma
+	Caption text	Başlık metni
+	Caption:	Başlık:
+	Chapter in a book	Kitapta bölüm
+	Chapters begin at:	Bölümler şunla başlar:
+	Collect entries from:	Girdileri şuradan topla:
+	Columns:	Sütunlar:
+	Conference	Konferans
+	Conference paper	Konferans bildirisi
+	Container Title	Kapsayıcı Başlığı
+	Create Source	Kaynak Oluştur
+	Cross-reference:	Çapraz başvuru:
+	Custom Table of Contents…	Özel İçindekiler Tablosu…
+	DOI	DOI
+	Day	Gün
+	Delete Label	Etiketi Sil
+	Edit Source	Kaynağı Düzenle
+	Edition	Baskı
+	Edit…	Düzenle…
+	Entry marked.	Girdi işaretlendi.
+	Example: {sample}	Örnek: {sample}
+	Figure	Şekil
+	Film	Film
+	Heading styles (levels 1–{n})	Başlık stilleri (1–{n}. düzeyler)
+	Heading {n}	Başlık {n}
+	I, II, III, …	I, II, III, …
+	Include page numbers	Sayfa numaralarını ekle
+	Indented	Girintili
+	Institution	Kurum
+	Ionosphere	İyonosfer
+	Issue	Sayı
+	Journal	Dergi
+	Label:	Etiket:
+	Last, First; Last, First	Soyadı, Adı; Soyadı, Adı
+	Leave the label out of the caption	Etiketi başlıktan çıkar
+	Letter headings	Harf başlıkları
+	Levels:	Düzeyler:
+	Link entries to their headings	Girdileri başlıklarına bağla
+	Made from the author and year when empty	Boşsa yazardan ve yıldan oluşturulur
+	Magazine or newspaper article	Dergi veya gazete makalesi
+	Main entry:	Ana girdi:
+	Mark	İşaretle
+	Mark All	Tümünü İşaretle
+	Mark Entry…	Girdiyi İşaretle…
+	Mark Index Entry	Dizin Girdisini İşaretle
+	Mesosphere	Mezosfer
+	Month	Ay
+	New Label	Yeni Etiket
+	New Label…	Yeni Etiket…
+	New…	Yeni…
+	No sources yet.	Henüz kaynak yok.
+	Numbering…	Numaralandırma…
+	Options…	Seçenekler…
+	Other	Diğer
+	Other styles and their TOC level:	Diğer stiller ve İçindekiler düzeyleri:
+	Outline levels	Anahat düzeyleri
+	Page number style	Sayfa numarası stili
+	Page numbers at the right margin	Sayfa numaraları sağ kenar boşluğunda
+	Page title	Sayfa başlığı
+	Pages of bookmark:	Yer işaretinin sayfaları:
+	Periodical	Süreli yayın
+	Position:	Konum:
+	Publisher	Yayıncı
+	Run-in	Yan yana
+	See	Bkz.
+	Separator:	Ayırıcı:
+	Show every bibliography field	Tüm kaynakça alanlarını göster
+	Site name	Site adı
+	Source Manager	Kaynak Yöneticisi
+	Source type:	Kaynak türü:
+	Sources in this document:	Bu belgedeki kaynaklar:
+	Styles:	Stiller:
+	Subentry:	Alt girdi:
+	TC entry fields	TC girdi alanları
+	Tab leader:	Sekme öncülü:
+	Table of Contents Options	İçindekiler Tablosu Seçenekleri
+	Table of Contents Styles	İçindekiler Tablosu Stilleri
+	This page	Bu sayfa
+	Type:	Tür:
+	URL	URL
+	Volume	Cilt
+	Website	Web sitesi
+	Year	Yıl
+	a, b, c, …	a, b, c, …
+	i, ii, iii, …	i, ii, iii, …
+	{n} entries marked.	{n} girdi işaretlendi.
+	Lasso Select	Kement Seçimi
+	Move Selected Ink	Seçili Mürekkebi Taşı
+	Delete Selected Ink	Seçili Mürekkebi Sil
+	Recolor Selected Ink	Seçili Mürekkebi Yeniden Renklendir
+	Add Pen	Kalem Ekle
+	Remove Pen	Kalemi Kaldır
+	Ink to Shape	Mürekkepten Şekle
+	Convert to Shapes	Şekillere Dönüştür
+	Ink Replay	Mürekkep Yeniden Oynatma
+	Add\nPen	Kalem\nEkle
+	Rewind	Geri Sar
+	Forward	İleri
+	Stroke {n} of {total}	Vuruş {n} / {total}
 	Drawing Canvas	Çizim Tuvali
 	New Drawing Canvas	Yeni Çizim Tuvali
 	Fit	Sığdır
@@ -1444,6 +1623,122 @@
 	Search icons	Simgelerde ara
 	No icons match your search.	Aramanızla eşleşen simge yok.
 	Recolor a one-color picture, such as an icon	Simge gibi tek renkli bir resmi yeniden renklendir
+	Templates	Şablonlar
+	Templates and Add-ins	Şablonlar ve Eklentiler
+	Attach Template	Şablonu Ekle
+	Detach Template	Şablonu Ayır
+	Automatically Update Document Styles	Belge Stillerini Otomatik Güncelle
+	Update Styles from Template	Stilleri Şablondan Güncelle
+	Organizer	Düzenleyici
+	Copy Styles	Stilleri Kopyala
+	Rename Style	Stili Yeniden Adlandır
+	Document template:	Belge şablonu:
+	Attach…	Ekle…
+	Automatically update document styles	Belge stillerini otomatik güncelle
+	Organizer…	Düzenleyici…
+	1. Formatting restrictions	1. Biçimlendirme kısıtlamaları
+	2. Editing restrictions	2. Düzenleme kısıtlamaları
+	3. Start enforcement	3. Korumayı başlat
+	<< Less	<< Daha az
+	Another file	Başka bir dosya
+	Apply as you type	Yazarken uygula
+	AutoCorrect	Otomatik Düzelt
+	AutoFormat As You Type	Yazarken Otomatik Biçimlendir
+	Automatic bulleted lists	Otomatik madde işaretli listeler
+	Automatic numbered lists	Otomatik numaralı listeler
+	Border lines	Kenarlık çizgileri
+	Capitalize first letter of sentences	Cümlelerin ilk harfini büyük yap
+	Capitalize first letter of table cells	Tablo hücrelerinin ilk harfini büyük yap
+	Capitalize names of days	Gün adlarını büyük harfle başlat
+	Case changes	Büyük/küçük harf değişiklikleri
+	Character level	Karakter düzeyi
+	Checked styles are allowed:	İşaretli stillere izin verilir:
+	Combine Documents	Belgeleri Birleştir
+	Compare Documents	Belgeleri Karşılaştır
+	Compared: {changes} changes	Karşılaştırıldı: {changes} değişiklik
+	Comparing with another file needs the desktop app.	Başka bir dosyayla karşılaştırma için masaüstü uygulaması gerekir.
+	Comparison settings	Karşılaştırma ayarları
+	Don't capitalize after:	Şundan sonra büyük harf yapma:
+	Editing in this document is restricted.	Bu belgede düzenleme kısıtlanmıştır.
+	Every change is recorded as a tracked change.	Her değişiklik izlenen değişiklik olarak kaydedilir.
+	Everyone	Herkes
+	Exceptions (optional)	Özel durumlar (isteğe bağlı)
+	Exceptions…	Özel durumlar…
+	Fields	Alanlar
+	Filling in forms	Form doldurma
+	Find Next Editable Region	Sonraki Düzenlenebilir Bölgeyi Bul
+	Footnotes and endnotes	Dipnotlar ve sonnotlar
+	Formatting, case changes, white space and tables are compared; the other settings are kept for later.	Biçimlendirme, harf büyüklüğü, boşluklar ve tablolar karşılaştırılır; diğer ayarlar daha sonra için saklanır.
+	Fractions (1/2) as fraction characters (½)	Kesirleri (1/2) kesir karakteri (½) olarak yaz
+	Headers and footers	Üst bilgiler ve alt bilgiler
+	Hyphens (--) as dashes (—)	Kısa çizgileri (--) uzun çizgi (—) olarak yaz
+	In equations, typing a name after a backslash replaces it with its symbol.	Denklemlerde ters eğik çizgiden sonra yazılan ad, simgesiyle değiştirilir.
+	Internet addresses as links	İnternet adreslerini bağlantı yap
+	Label changes with:	Değişiklikleri şununla etiketle:
+	Limit formatting to a selection of styles	Biçimlendirmeyi seçili stillerle sınırla
+	Math AutoCorrect	Matematik Otomatik Düzelt
+	More >>	Daha fazla >>
+	Moves	Taşımalar
+	New document	Yeni belge
+	No changes (read only)	Değişiklik yok (salt okunur)
+	Only allow this kind of editing:	Yalnızca bu tür düzenlemeye izin ver:
+	Only comments can be added, except in regions marked editable.	Düzenlenebilir işaretli bölgeler dışında yalnızca yorum eklenebilir.
+	Only form fields can be filled in.	Yalnızca form alanları doldurulabilir.
+	Only the allowed styles can be applied.	Yalnızca izin verilen stiller uygulanabilir.
+	Ordinals (1st) as superscript	Sıra sayılarını (1st) üst simge yap
+	Original document	Özgün belge
+	This password type isn't supported.	Bu parola türü desteklenmiyor.
+	Replace as you type	Yazarken değiştir
+	Replace text as you type	Yazarken metni değiştir
+	Replace:	Değiştirilecek:
+	Revised document	Düzeltilmiş belge
+	Select text, then tick who can still edit it.	Metni seçin, sonra kimlerin düzenleyebileceğini işaretleyin.
+	Settings…	Ayarlar…
+	Show changes at:	Değişiklikleri göster:
+	Show changes in:	Değişiklikleri şurada göster:
+	Smart quotes instead of straight quotes	Düz tırnak yerine akıllı tırnak
+	Start Enforcing Protection	Korumayı Başlat
+	Stop Protection	Korumayı Durdur
+	Text boxes	Metin kutuları
+	The document is read only, except for regions marked editable.	Düzenlenebilir işaretli bölgeler dışında belge salt okunurdur.
+	The password is optional; without it anyone can stop the protection.	Parola isteğe bağlıdır; olmadan herkes korumayı durdurabilir.
+	This document	Bu belge
+	Tracked changes	İzlenen değişiklikler
+	Type the password to stop the protection.	Korumayı durdurmak için parolayı yazın.
+	White space	Boşluk
+	With:	Yeni:
+	Word level	Sözcük düzeyi
+	Change Chart Type	Grafik Türünü Değiştir
+	Chart Design	Grafik Tasarımı
+	Type	Tür
+	Edit Data	Verileri Düzenle
+	Chart Title	Grafik Başlığı
+	Chart Layouts	Grafik Düzenleri
+	Add Chart Element	Grafik Öğesi Ekle
+	Legend	Gösterge
+	Data Labels	Veri Etiketleri
+	Above Chart	Grafiğin Üstünde
+	Insert Chart	Grafik Ekle
+	Clustered Column	Kümelenmiş Sütun
+	Stacked Column	Yığılmış Sütun
+	Clustered Bar	Kümelenmiş Çubuk
+	Stacked Bar	Yığılmış Çubuk
+	Area	Alan
+	Pie	Pasta
+	Doughnut	Halka
+	Scatter	Dağılım
+	“{text}” ({row}, {series}) isn't a number.	“{text}” ({row}, {series}) bir sayı değil.
+	Category {n}	Kategori {n}
+	Series {n}	Seri {n}
+	Type the categories down the side and a column of values per series.	Kategorileri yan tarafa, her seri için bir değer sütunu yazın.
+	Categories	Kategoriler
+	Series name	Seri adı
+	Remove series	Seriyi kaldır
+	Remove row	Satırı kaldır
+	Add Row	Satır Ekle
+	Add Series	Seri Ekle
+	Edit\nData	Verileri\nDüzenle
+	Change\nChart Type	Grafik Türünü\nDeğiştir
 	Align Text	Metni Hizala
 	Create Link	Bağlantı Oluştur
 	Break Link	Bağlantıyı Kes
@@ -1465,3 +1760,293 @@
 	Continuous numbering	Sürekli numaralandırma
 	Apply	Uygula
 	Convert Notes	Notları Dönüştür
+
+# Built-in file browser (#576).
+	Documents	Belgeler
+	Word document	Word belgesi
+	All files	Tüm dosyalar
+	Recipient lists	Alıcı listeleri
+	The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity.	Sistemin dosya iletişim kutusu kullanılamadığı için WordCraft kendi iletişim kutusunu gösteriyor. Sistem iletişim kutusunu kullanmak için bir dosya seçici portalı (örneğin xdg-desktop-portal-gtk) ya da zenity yükleyin.
+	Up one level	Bir düzey yukarı
+	Home folder	Ana klasör
+	{name} wasn't found.	{name} bulunamadı.
+	{name} already exists. Choose Save again to replace it.	{name} zaten var. Değiştirmek için Kaydet'i yeniden seçin.
+	This folder can't be read: {error}	Bu klasör okunamıyor: {error}
+	Showing the first {count} items.	İlk {count} öğe gösteriliyor.
+	File name:	Dosya adı:
+	Browse in WordCraft…	WordCraft'ta Gözat…
+	Open a file with WordCraft's own browser when the system file dialog doesn't appear.	Sistemin dosya iletişim kutusu açılmadığında dosyayı WordCraft'ın kendi dosya tarayıcısıyla açın.
+	Hide White Space	Boşluğu gizle
+	All pages	Tüm sayfalar
+	Current page	Geçerli sayfa
+	Selected pages	Seçili sayfalar
+	Custom range	Özel aralık
+	All pages in the range	Aralıktaki tüm sayfalar
+	Odd pages only	Yalnızca tek sayfalar
+	Even pages only	Yalnızca çift sayfalar
+	Copies	Kopya
+	Collate copies	Kopyaları harmanla
+	Pages like 1-3, 5	Sayfalar, örn. 1-3, 5
+	{count} of {total} pages will print	{total} sayfadan {count} sayfa yazdırılacak
+	Save these pages as PDF…	Bu sayfaları PDF olarak kaydet…
+	The printer, two-sided printing and pages per sheet are chosen in that dialog.	Yazıcı, çift taraflı yazdırma ve yaprak başına sayfa sayısı o iletişim kutusunda seçilir.
+	Previous Page	Önceki sayfa
+	Print to PDF	PDF'ye yazdır
+# Word XML Document (#548).
+	Word XML Document (*.xml)	Word XML Belgesi (*.xml)
+# Find and Replace special characters and wildcards (#543).
+	Use wildcards	Joker karakter kullan
+	Special	Özel
+	Match prefix	Ön eke uy
+	Match suffix	Son eke uy
+	Ignore punctuation characters	Noktalama karakterlerini yoksay
+	Ignore white-space characters	Boşluk karakterlerini yoksay
+	Regular expressions	Düzenli ifadeler
+	Search Options	Arama Seçenekleri
+	Tab Character	Sekme Karakteri
+	Any Character	Herhangi Bir Karakter
+	Any Digit	Herhangi Bir Rakam
+	Any Letter	Herhangi Bir Harf
+	Caret Character	Şapka Karakteri
+	Section Character	Bölüm Karakteri
+	Paragraph Character	Paragraf Karakteri
+	Graphic	Grafik
+	Manual Line Break	El ile Satır Sonu
+	Manual Page Break	El ile Sayfa Sonu
+	Section Break	Bölüm Sonu
+	White Space	Boşluk
+	Clipboard Contents	Pano İçeriği
+	Find What Text	Aranan Metin
+	Find What Expression	Aranan İfade
+	Character in Range	Aralıktaki Karakter
+	Beginning of Word	Sözcük Başı
+	End of Word	Sözcük Sonu
+	Expression	İfade
+	Not	Değil
+	Num Occurrences	Tekrar Sayısı
+	Previous 1 or More	Öncekinin 1 veya Daha Fazlası
+	0 or More Characters	0 veya Daha Fazla Karakter
+# Insert SmartArt (#497).
+	Add Shape	Şekil Ekle
+	Change Colors	Renkleri Değiştir
+	Change Layout	Düzeni Değiştir
+	Create Graphic	Grafik Oluştur
+	Edit Items	Öğeleri Düzenle
+	Layouts	Düzenler
+	Reset Graphic	Grafiği Sıfırla
+	SmartArt Design	SmartArt Tasarımı
+	SmartArt Styles	SmartArt Stilleri
+	Text Pane	Metin Bölmesi
+	List	Liste
+	Process	Süreç
+	Cycle	Döngü
+	Hierarchy	Hiyerarşi
+	Relationship	İlişki
+	Pyramid	Piramit
+	Basic List	Temel Liste
+	Basic Process	Temel Süreç
+	Basic Cycle	Temel Döngü
+	Basic Pyramid	Temel Piramit
+	Basic Radial	Temel Radyal
+	Basic Matrix	Temel Matris
+	Basic Venn	Temel Venn
+	Shows items of equal weight as blocks in rows.	Eşit ağırlıktaki öğeleri satırlar halinde bloklar olarak gösterir.
+	Shows steps in order, left to right, with arrows between them.	Adımları soldan sağa sırayla, aralarında oklarla gösterir.
+	Shows steps that repeat, around a circle.	Yinelenen adımları daire etrafında gösterir.
+	Shows a tree: each item below the item it belongs to.	Bir ağaç gösterir: her öğe ait olduğu öğenin altındadır.
+	Shows parts that build on each other, largest at the bottom.	Birbirinin üzerine kurulan parçaları, en büyüğü altta olacak şekilde gösterir.
+	Shows items around a central idea: the first item is the centre.	Öğeleri merkezi bir fikrin çevresinde gösterir: ilk öğe merkezdedir.
+	Shows parts of a whole as quadrants.	Bütünün parçalarını dörtte birlikler olarak gösterir.
+	Shows overlapping ideas as overlapping circles.	Örtüşen fikirleri iç içe geçen daireler olarak gösterir.
+	Accent {n}	Vurgu {n}
+	Colorful	Renkli
+	Insert SmartArt	SmartArt Ekle
+	One line per item. Enter adds an item.	Öğe başına bir satır. Enter bir öğe ekler.
+	Add\nShape	Şekil\nEkle
+	Change\nColors	Renkleri\nDeğiştir
+	Reset\nGraphic	Grafiği\nSıfırla
+# Outline view (#493).
+	Promote to Heading 1	Başlık 1'e yükselt
+	Demote to Body Text	Gövde metnine düşür
+	Move Up	Yukarı taşı
+	Move Down	Aşağı taşı
+	Collapse	Daralt
+	Expand or Collapse Heading	Başlığı genişlet veya daralt
+	Select Heading and Content	Başlığı ve içeriğini seç
+	Show Level	Düzeyi göster
+	Show Level 1	Düzey 1'i göster
+	Show Level 2	Düzey 2'yi göster
+	Show Level 3	Düzey 3'ü göster
+	Show Level 4	Düzey 4'ü göster
+	Show Level 5	Düzey 5'i göster
+	Show Level 6	Düzey 6'yı göster
+	Show Level 7	Düzey 7'yi göster
+	Show Level 8	Düzey 8'i göster
+	Show Level 9	Düzey 9'u göster
+	Show All Levels	Tüm düzeyleri göster
+	All Levels	Tüm düzeyler
+	Show First Line Only	Yalnızca ilk satırı göster
+	Show Text Formatting	Metin biçimlendirmesini göster
+	Close Outline View	Anahat görünümünü kapat
+	Outline State	Anahat durumu
+	Outlining	Anahat
+	Outline Tools	Anahat araçları
+	Close Outline\nView	Anahat görünümünü\nkapat
+# Wrap Text context menu (#513).
+	Move with Text	Metinle birlikte taşı
+	Fix Position on Page	Sayfadaki konumu sabitle
+# Paragraph dialog options (#512).
+	Formatting exceptions	Biçimlendirme özel durumları
+	Inside:	İç:
+	Mirror indents	Ayna girintiler
+	Outside:	Dış:
+# WordArt and connectors (#416).
+	WordArt Styles	WordArt Stilleri
+	Text Fill	Metin Dolgusu
+	Text Outline	Metin Anahattı
+	Transform	Dönüştür
+	No Fill	Dolgu Yok
+	No Outline	Anahat Yok
+	Reflection	Yansıma
+	No Reflection	Yansıma Yok
+	No Transform	Dönüşüm Yok
+	Connect Shapes	Şekilleri Bağla
+	Straight Connector	Düz Bağlayıcı
+	Straight Arrow Connector	Düz Oklu Bağlayıcı
+	Elbow Connector	Dirsekli Bağlayıcı
+	Elbow Arrow Connector	Dirsekli Oklu Bağlayıcı
+	Curved Connector	Eğri Bağlayıcı
+	Curved Arrow Connector	Eğri Oklu Bağlayıcı
+	Arch Up	Yukarı Kemer
+	Arch Down	Aşağı Kemer
+	Slant Up	Yukarı Eğim
+	Slant Down	Aşağı Eğim
+	Inflate	Şişir
+	Deflate	Söndür
+	Chevron Up	Yukarı Şevron
+	Chevron Down	Aşağı Şevron
+	Triangle Up	Yukarı Üçgen
+	Triangle Down	Aşağı Üçgen
+	Solid Accent	Düz Vurgu
+	Light with Outline	Anahatlı Açık
+	Hollow	İçi Boş
+	Accent Gradient	Vurgu Geçişi
+	Dark with Shadow	Gölgeli Koyu
+	Soft Glow	Yumuşak Parıltı
+	Accent with Reflection	Yansımalı Vurgu
+	Warm Gradient with Outline	Anahatlı Sıcak Geçiş
+	Add line numbering	Satır numaralandırma ekle
+	Add to Document	Belgeye Ekle
+	Address labels	Adres etiketleri
+	Arabic	Arapça
+	Auto	Otomatik
+	Automatically hyphenate document	Belgede otomatik heceleme yap
+	Chinese (Simplified)	Çince (Basitleştirilmiş)
+	Chinese (Traditional)	Çince (Geleneksel)
+	Column:	Sütun:
+	Count by:	Artış:
+	Czech	Çekçe
+	Danish	Danca
+	Delivery address:	Teslimat adresi:
+	Detect language automatically	Dili otomatik algıla
+	Do not check spelling or grammar	Yazım ve dil bilgisini denetleme
+	Dutch	Felemenkçe
+	Envelope size:	Zarf boyutu:
+	Estonian	Estonca
+	Finnish	Fince
+	French (France)	Fransızca (Fransa)
+	From text:	Metinden:
+	Full page of the same label	Aynı etiketten tam sayfa
+	German (Germany)	Almanca (Almanya)
+	Greek	Yunanca
+	Hebrew	İbranice
+	Hyphenate at:	Hecele:
+	Hyphenate words in CAPS	BÜYÜK HARFLİ sözcükleri hecele
+	Hyphenation Options…	Heceleme Seçenekleri…
+	Hyphenation zone:	Heceleme bölgesi:
+	Italian	İtalyanca
+	Japanese	Japonca
+	Korean	Korece
+	Limit consecutive hyphens to:	Ardışık tireleri şununla sınırla:
+	Line Numbering Options…	Satır Numaralandırma Seçenekleri…
+	Manual Hyphenation	El ile Heceleme
+	Manual hyphenation is complete.	El ile heceleme tamamlandı.
+	Manual…	El ile…
+	Mark selected text as:	Seçili metni şu olarak işaretle:
+	New Document	Yeni Belge
+	No limit	Sınır yok
+	Norwegian (Bokmål)	Norveççe (Bokmål)
+	Numbering:	Numaralandırma:
+	Omit	Atla
+	One label per recipient	Alıcı başına bir etiket
+	Portuguese (Brazil)	Portekizce (Brezilya)
+	Portuguese (Portugal)	Portekizce (Portekiz)
+	Return address labels	Gönderen adresi etiketleri
+	Return address:	Gönderen adresi:
+	Row:	Satır:
+	Russian	Rusça
+	Serbian (Cyrillic)	Sırpça (Kiril)
+	Serbian (Latin)	Sırpça (Latin)
+	Set As Default	Varsayılan Olarak Ayarla
+	Shipping labels	Kargo etiketleri
+	Single label	Tek etiket
+	Spanish (Mexico)	İspanyolca (Meksika)
+	Spanish (Spain)	İspanyolca (İspanya)
+	Swedish	İsveççe
+	Turkish	Türkçe
+	Ukrainian	Ukraynaca
+	{language} is now the document's default language.	{language} artık belgenin varsayılan dili.
+# File > Options panes (#485).
+	As you type	Yazarken
+	AutoSave writes your changes to the file a moment after you stop typing.	Otomatik kaydetme, yazmayı bıraktıktan kısa süre sonra değişikliklerinizi dosyaya yazar.
+	Centimeters	Santimetre
+	Check spelling as you type	Yazarken yazımı denetle
+	Click to switch back to inserting	Eklemeye geri dönmek için tıklayın
+	Custom dictionary	Özel sözlük
+	Formatting marks	Biçimlendirme işaretleri
+	Hidden text	Gizli metin
+	Ignore web and file addresses	Web ve dosya adreslerini yoksay
+	Ignore words in capitals	Büyük harfli sözcükleri yoksay
+	Ignore words with numbers	Rakam içeren sözcükleri yoksay
+	Inches	İnç
+	Initials:	Baş harfler:
+	Interface	Arayüz
+	Interface language	Arayüz dili
+	Mark grammar errors as you type	Yazarken dil bilgisi hatalarını işaretle
+	Measurement units:	Ölçü birimleri:
+	Millimeters	Milimetre
+	New comments and tracked changes are recorded under this name and these initials.	Yeni açıklamalar ve izlenen değişiklikler bu ad ve baş harflerle kaydedilir.
+	New word	Yeni sözcük
+	No words yet. Add to Dictionary on a misspelled word puts it here.	Henüz sözcük yok. Yanlış yazılmış bir sözcükte «Sözlüğe ekle» onu buraya koyar.
+	Overtype	Üzerine yaz
+	Overtype (typing replaces the characters after the caret)	Üzerine yazma (yazılan metin imleçten sonraki karakterlerin yerine geçer)
+	Page display	Sayfa görünümü
+	Paragraph marks	Paragraf işaretleri
+	Personalize	Kişiselleştir
+	Picas	Pika
+	Points	Punto
+	Print the page color	Sayfa rengini yazdır
+	Printing	Yazdırma
+	Proofing language	Yazım denetimi dili
+	Recent documents to show:	Gösterilecek son belge sayısı:
+	Save documents	Belgeleri kaydet
+	Show the mini toolbar when text is selected	Metin seçildiğinde mini araç çubuğunu göster
+	Spaces	Boşluklar
+	Spelling	Yazım
+	Spelling and grammar are checked in English (United States).	Yazım ve dil bilgisi İngilizce (Amerika Birleşik Devletleri) için denetlenir.
+	Tab characters	Sekme karakterleri
+	These marks show even when Show/Hide ¶ is off.	Bu işaretler, Göster/Gizle ¶ kapalıyken de görünür.
+	Typing replaces selected text	Yazmak seçili metnin yerine geçer
+	Update fields before printing	Yazdırmadan önce alanları güncelle
+	Use the Insert key to switch overtype on and off	Üzerine yazmayı açıp kapatmak için Insert tuşunu kullan
+# Asian and Latin text fonts (#505).
+	Asian text font:	Asya metni yazı tipi:
+	Latin text font:	Latin metni yazı tipi:
+	Visual effects	Görsel efektler
+	Animation effects:	Animasyon efektleri:
+	On	Açık
+	Off	Kapalı
+	Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.	Yumuşak kaydırma ve yakınlaştırma ile menülerin ve düğmelerin yavaşça belirmesi. Kapalı seçildiğinde her değişiklik anında gösterilir.
+	Your system has animation effects turned on.	Sisteminizde animasyon efektleri açık.
+	Your system has animation effects turned off.	Sisteminizde animasyon efektleri kapalı.
+	Your system doesn't report an animation setting, so animation effects stay on.	Sisteminiz bir animasyon ayarı bildirmiyor, bu nedenle animasyon efektleri açık kalır.
diff --git a/crates/ui-egui/src/i18n/uk.tsv b/crates/ui-egui/src/i18n/uk.tsv
index 17cad4ddf8..c7efa79df9 100644
--- a/crates/ui-egui/src/i18n/uk.tsv
+++ b/crates/ui-egui/src/i18n/uk.tsv
@@ -60,12 +60,15 @@
 	Arrange\nAll	Упорядкувати\nвсі
 	Arrow	Стрілка
 	Artistic Effects	Художні ефекти
+	As you type	Під час введення
+	Asian text font:	Шрифт азійського тексту:
 	Asian Typography	Азійська типографіка
 	Author	Автор
 	AutoCorrect Options	Параметри автовиправлення
 	AutoFit	Добір розміру
 	AutoFit Contents	Добір розміру за вмістом
 	AutoFit Window	Добір розміру за шириною вікна
+	AutoSave writes your changes to the file a moment after you stop typing.	Автозбереження записує зміни у файл невдовзі після того, як ви припините вводити текст.
 	Automatic	Автоматично
 	Automatic ({language})	Автоматично ({language})
 	Automatic follows your system's language. Menus and commands change; your documents don't.	Автоматичний режим використовує мову вашої системи. Змінюються меню й команди, а вміст документів залишається незмінним.
@@ -78,30 +81,67 @@
 	Balloons	Виноски
 	Bullet	Маркер
 	By author	За автором
+	Centimeters	Сантиметри
 	Changed lines:	Змінені рядки:
+	Check spelling as you type	Перевіряти правопис під час введення
 	Click level to modify:	Виберіть рівень для змінення:
+	Click to switch back to inserting	Клацніть, щоб повернутися до вставлення
 	Color only	Лише колір
+	Custom dictionary	Власний словник
 	Define New Multilevel List	Визначити новий багаторівневий список
 	Define New Multilevel List…	Визначити новий багаторівневий список…
 	Deletions:	Видалення:
 	Enter formatting for number:	Вигляд номера:
 	Follow number with:	Після номера:
 	Formatting	Форматування
+	Formatting marks	Знаки форматування
+	Hidden text	Прихований текст
+	Ignore web and file addresses	Пропускати веб-адреси та шляхи до файлів
+	Ignore words in capitals	Пропускати слова з великих літер
+	Ignore words with numbers	Пропускати слова з цифрами
+	Inches	Дюйми
+	Formatting exceptions	Винятки форматування
 	Include level number from:	Додати номер рівня:
+	Initials:	Ініціали:
 	Ink	Рукописні примітки
 	Insertions and Deletions	Вставлення й видалення
 	Insertions:	Вставлення:
+	Interface	Інтерфейс
+	Interface language	Мова інтерфейсу
+	Inside:	Усередині:
+	Latin text font:	Шрифт латинського тексту:
 	Left border	Ліва межа
 	Legal style numbering	Юридична нумерація
 	Link level to style:	Зв'язати рівень зі стилем:
 	List Definition	Визначення списку
+	Mark grammar errors as you type	Позначати граматичні помилки під час введення
+	Measurement units:	Одиниці виміру:
+	Millimeters	Міліметри
+	New comments and tracked changes are recorded under this name and these initials.	Нові коментарі та відстежувані зміни записуються під цим іменем і цими ініціалами.
+	New word	Нове слово
+	No words yet. Add to Dictionary on a misspelled word puts it here.	Слів ще немає. «Додати до словника» для слова з помилкою додає його сюди.
+	Mirror indents	Дзеркальні відступи
 	Nothing	Нічого
 	Number alignment:	Вирівнювання номера:
 	Number format	Формат номера
 	Number style for this level:	Стиль номера для цього рівня:
 	Outside border	Зовнішня межа
+	Overtype	Заміна
+	Overtype (typing replaces the characters after the caret)	Заміна (введений текст замінює символи після курсора)
+	Page display	Відображення сторінки
+	Paragraph marks	Знаки абзацу
+	Personalize	Персоналізація
+	Picas	Піки
+	Points	Пункти
+	Print the page color	Друкувати колір сторінки
+	Printing	Друк
+	Proofing language	Мова перевірки
+	Recent documents to show:	Кількість останніх документів:
+	Remove	Вилучити
+	Outside:	Зовні:
 	Restart list after:	Почати список знову після:
 	Right border	Права межа
+	Save documents	Збереження документів
 	Save the document to turn on AutoSave	Збережіть документ, щоб увімкнути автозбереження
 	Save the document to turn on AutoSave (a file you have only opened isn't rewritten until you save it)	Збережіть документ, щоб увімкнути автозбереження (файл, який ви лише відкрили, не перезаписується, доки ви його не збережете)
 	AutoText	Автоматичний текст
@@ -124,6 +164,11 @@
 	Border Painter	Пензель меж
 	Border\nPainter	Пензель\nмеж
 	Borders	Межі
+	Show the mini toolbar when text is selected	Показувати міні-панель інструментів під час виділення тексту
+	Spaces	Пробіли
+	Spelling	Правопис
+	Spelling and grammar are checked in English (United States).	Правопис і граматика перевіряються англійською (США).
+	Tab characters	Символи табуляції
 	Tab stop position:	Позиція табуляції:
 	Default tab stops:	Типові позиції табуляції:
 	Tab stops to be cleared:	Позиції, які буде видалено:
@@ -134,6 +179,10 @@
 	Set	Встановити
 	Page Border	Межа сторінки
 	Apply to:	Застосувати до:
+	These marks show even when Show/Hide ¶ is off.	Ці знаки відображаються, навіть коли «Показати/приховати ¶» вимкнено.
+	Typing replaces selected text	Введення замінює виділений текст
+	Update fields before printing	Оновлювати поля перед друком
+	Use the Insert key to switch overtype on and off	Клавіша Insert вмикає та вимикає режим заміни
 	Whole document	Увесь документ
 	This section	Цей розділ
 	Fill	Колір заливки
@@ -277,7 +326,6 @@
 	Distribute spacing	Розподілити інтервали
 	Offset (pt):	Зсув (пункти):
 	Phonetic Guide	Фонетична підказка
-	Remove	Прибрати
 	Right (vertical)	Праворуч (вертикально)
 	Ruby text:	Текст рубі:
 	Search for templates	Пошук шаблонів
@@ -342,6 +390,7 @@
 	Export PDF	Експортувати PDF
 	Exported {path}	Експортовано {path}
 	Extend Selection	Розширити виділення
+	Extend Selection by Units	Розширити виділення за одиницями
 	Field	Поле
 	File	Файл
 	Find	Знайти
@@ -761,6 +810,9 @@
 	Show only comments and formatting in balloons	Показувати у виносках лише коментарі й форматування
 	Show revisions in balloons	Показувати виправлення у виносках
 	Show rulers	Показати лінійки
+	Animation	Анімація
+	Animate the caret (it glides and fades)	Анімувати каретку (плавно рухається та згасає)
+	On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off.	Увімкнено: каретка плавно переходить на нове місце, коли ви вводите текст або користуєтеся стрілками, а її блимання згасає поступово. Вимкнено: вона перестрибує й блимає різко.
 	Show the community button in the title bar	Показувати кнопку спільноти в заголовку вікна
 	Show/Hide ¶	Показати/приховати ¶
 	Show\nComments	Показати\nкоментарі
@@ -905,10 +957,10 @@
 	Wide	Широкі
 	Widow/Orphan Control	Не залишати самотні рядки
 	Widow/Orphan control	Не залишати самотні рядки
-	Wildcards (regex)	Шаблони (регулярні вирази)
 	Window	Вікно
 	Word Count	Кількість слів
 	Word document (*.docx)	Документ Word (*.docx)
+	Word XML Document (*.xml)	Документ Word XML (*.xml)
 	Word Left	На слово ліворуч
 	Word Right	На слово праворуч
 	WordArt	WordArt
@@ -1360,8 +1412,86 @@
 	Selected Fields	Вибрані поля
 	Edit Field…	Змінити поле…
 	Formatted	Відформатовано
+	Deleted	Видалено
 	Interface size:	Розмір інтерфейсу:
 	Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate.	Збільшує або зменшує стрічку, меню й діалогові вікна понад системне масштабування екрана. Масштаб документа налаштовується окремо.
+	Resize Table by Dragging	Змінити розмір таблиці перетягуванням
+	Print Markup	Друкувати примітки та виправлення
+	Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text.	Коментарі біля кожної сторінки й відстежені зміни в PDF, друку та зображеннях; список коментарів наприкінці вебсторінок, Markdown і тексту.
+
+# Compare / Combine, AutoCorrect Options and Restrict Editing (#412)
+	1. Formatting restrictions	1. Обмеження форматування
+	2. Editing restrictions	2. Обмеження редагування
+	3. Start enforcement	3. Увімкнення захисту
+	<< Less	<< Менше
+	Another file	Інший файл
+	Apply as you type	Застосовувати під час введення
+	AutoCorrect	Автовиправлення
+	AutoFormat As You Type	Автоформат під час введення
+	Automatic bulleted lists	Автоматичні марковані списки
+	Automatic numbered lists	Автоматичні нумеровані списки
+	Border lines	Лінії меж
+	Capitalize first letter of sentences	Перша літера речення велика
+	Capitalize first letter of table cells	Перша літера в клітинках таблиці велика
+	Capitalize names of days	Назви днів із великої літери
+	Case changes	Зміни регістру
+	Character level	Рівень символів
+	Checked styles are allowed:	Позначені стилі дозволено:
+	Combine Documents	Об'єднання документів
+	Compare Documents	Порівняння документів
+	Compared: {changes} changes	Порівняно: змін {changes}
+	Comparing with another file needs the desktop app.	Для порівняння з іншим файлом потрібна настільна програма.
+	Comparison settings	Параметри порівняння
+	Don't capitalize after:	Не робити великої літери після:
+	Editing in this document is restricted.	Редагування цього документа обмежено.
+	Every change is recorded as a tracked change.	Кожна зміна записується як відстежувана.
+	Everyone	Усі
+	Exceptions (optional)	Винятки (необов'язково)
+	Exceptions…	Винятки…
+	Fields	Поля
+	Filling in forms	Заповнення форм
+	Find Next Editable Region	Знайти наступну область для редагування
+	Footnotes and endnotes	Виноски та кінцеві виноски
+	Formatting, case changes, white space and tables are compared; the other settings are kept for later.	Порівнюються форматування, регістр, пробіли й таблиці; інші параметри збережено на майбутнє.
+	Fractions (1/2) as fraction characters (½)	Дроби (1/2) як символи дробів (½)
+	Headers and footers	Колонтитули
+	Hyphens (--) as dashes (—)	Дефіси (--) як тире (—)
+	In equations, typing a name after a backslash replaces it with its symbol.	У рівняннях назва після зворотної скісної риски замінюється символом.
+	Internet addresses as links	Інтернет-адреси як посилання
+	Label changes with:	Позначати зміни іменем:
+	Limit formatting to a selection of styles	Обмежити форматування вибраними стилями
+	Math AutoCorrect	Математичне автовиправлення
+	More >>	Більше >>
+	Moves	Переміщення
+	New document	Новий документ
+	No changes (read only)	Без змін (лише читання)
+	Only allow this kind of editing:	Дозволити лише такий тип редагування:
+	Only comments can be added, except in regions marked editable.	Можна лише додавати коментарі, крім областей, позначених для редагування.
+	Only form fields can be filled in.	Можна заповнювати лише поля форми.
+	Only the allowed styles can be applied.	Можна застосовувати лише дозволені стилі.
+	Ordinals (1st) as superscript	Порядкові (1st) як надрядкові
+	Original document	Вихідний документ
+	This password type isn't supported.	Цей тип пароля не підтримується.
+	Replace as you type	Замінювати під час введення
+	Replace text as you type	Замінювати текст під час введення
+	Replace:	Замінити:
+	Revised document	Змінений документ
+	Select text, then tick who can still edit it.	Виділіть текст і позначте, хто може його редагувати.
+	Settings…	Параметри…
+	Show changes at:	Показувати зміни на рівні:
+	Show changes in:	Показувати зміни в:
+	Smart quotes instead of straight quotes	Типографські лапки замість прямих
+	Start Enforcing Protection	Увімкнути захист
+	Stop Protection	Вимкнути захист
+	Text boxes	Текстові поля
+	The document is read only, except for regions marked editable.	Документ лише для читання, крім областей, позначених для редагування.
+	The password is optional; without it anyone can stop the protection.	Пароль необов'язковий; без нього будь-хто може вимкнути захист.
+	This document	Цей документ
+	Tracked changes	Відстежувані зміни
+	Type the password to stop the protection.	Введіть пароль, щоб вимкнути захист.
+	White space	Пробіли
+	With:	На:
+	Word level	Рівень слів
 	In Line with Text	У рядку з текстом
 	Square	Квадрат
 	Through	Наскрізне
@@ -1408,6 +1538,36 @@
 	New Group	Нова група
 	Rename…	Перейменувати…
 	Ribbon and Quick Access Toolbar:	Стрічка й панель швидкого доступу:
+	Add Font…	Додати шрифт…
+	Added Fonts	Додані шрифти
+	Remove Added Font	Видалити доданий шрифт
+	Recent Colors	Останні кольори
+	More Colors…	Інші кольори…
+	Standard	Стандартні
+	Current	Поточний
+	Colors:	Кольори:
+	Color model:	Колірна модель:
+	Red:	Червоний:
+	Green:	Зелений:
+	Blue:	Синій:
+	Hue:	Відтінок:
+	Sat:	Насиченість:
+	Lum:	Яскравість:
+	Hex:	Hex:
+	Accessibility Pane	Панель доступності
+	Alt Text Pane	Панель альтернативного тексту
+	Alt\nText	Альтернативний\nтекст
+	View Alt Text…	Переглянути альтернативний текст…
+	Mark as decorative	Позначити як декоративний
+	Title:	Заголовок:
+	Errors ({n})	Помилки ({n})
+	Warnings ({n})	Попередження ({n})
+	Tips ({n})	Поради ({n})
+	No accessibility issues found.	Проблем із доступністю не знайдено.
+	Describe what this object shows, for people who can't see it.	Опишіть, що показує цей об’єкт, для тих, хто не може його бачити.
+	Decorative objects only add visual interest: screen readers skip them.	Декоративні об’єкти лише прикрашають документ: засоби читання з екрана їх пропускають.
+	Describe what this table shows, for people who can't see it.	Опишіть, що показує ця таблиця, для тих, хто не може її бачити.
+	Select a picture, shape, chart or table to describe it.	Виберіть зображення, фігуру, діаграму або таблицю, щоб описати її.
 	Document Grid	Сітка документа
 	No grid	Без сітки
 	Lines only	Лише рядки
@@ -1417,6 +1577,39 @@
 	Lines per page:	Рядків на сторінці:
 	Moved from	Переміщено звідси
 	Moved to	Переміщено сюди
+	Developer	Розробник
+	Controls	Елементи керування
+	Rich Text Content Control	Елемент керування вмістом «Форматований текст»
+	Plain Text Content Control	Елемент керування вмістом «Звичайний текст»
+	Picture Content Control	Елемент керування вмістом «Зображення»
+	Building Block Gallery Content Control	Елемент керування вмістом «Колекція стандартних блоків»
+	Check Box Content Control	Елемент керування вмістом «Прапорець»
+	Combo Box Content Control	Елемент керування вмістом «Поле зі списком»
+	Drop-Down List Content Control	Елемент керування вмістом «Розкривний список»
+	Date Picker Content Control	Елемент керування вмістом «Вибір дати»
+	Repeating Section Content Control	Елемент керування вмістом «Розділ, що повторюється»
+	Design Mode	Режим конструктора
+	Content Control at Selection	Елемент керування вмістом у виділенні
+	Toggle Check Box	Перемкнути прапорець
+	Choose List Item	Вибрати елемент списку
+	Set Date	Задати дату
+	Remove Content Control	Видалити елемент керування вмістом
+	Content Control Properties	Властивості елемента керування вмістом
+	Title	Назва
+	Tag	Тег
+	Placeholder text	Текст заповнювача
+	Can't be deleted	Не можна видалити
+	Contents can't be edited	Вміст не можна редагувати
+	Remove the control once edited	Видалити елемент після редагування
+	Allow line breaks	Дозволити розриви рядків
+	Date format	Формат дати
+	Checked symbol	Символ увімкненого стану
+	Unchecked symbol	Символ вимкненого стану
+	List entries	Елементи списку
+	Display text	Текст для показу
+	Value	Значення
+	Today	Сьогодні
+	Put the caret in a content control first.	Спершу поставте курсор в елемент керування вмістом.
 	Right-to-Left Table	Таблиця справа наліво
 	Right-to-Left Section	Розділ справа наліво
 	Table direction:	Напрямок таблиці:
@@ -1444,6 +1637,50 @@
 	Enlarge symbol	Збільшити символ
 	Enclosure	Обведення
 	Circle	Коло
+	Templates	Шаблони
+	Templates and Add-ins	Шаблони й надбудови
+	Attach Template	Приєднати шаблон
+	Detach Template	Від'єднати шаблон
+	Automatically Update Document Styles	Автоматично оновлювати стилі документа
+	Update Styles from Template	Оновити стилі із шаблону
+	Organizer	Організатор
+	Copy Styles	Копіювати стилі
+	Rename Style	Перейменувати стиль
+	Document template:	Шаблон документа:
+	Attach…	Приєднати…
+	Automatically update document styles	Автоматично оновлювати стилі документа
+	Organizer…	Організатор…
+	Change Chart Type	Змінити тип діаграми
+	Chart Design	Конструктор діаграми
+	Type	Тип
+	Edit Data	Редагувати дані
+	Chart Title	Назва діаграми
+	Chart Layouts	Макети діаграми
+	Add Chart Element	Додати елемент діаграми
+	Legend	Легенда
+	Data Labels	Підписи даних
+	Above Chart	Над діаграмою
+	Insert Chart	Вставити діаграму
+	Clustered Column	Стовпці з групуванням
+	Stacked Column	Стовпці з накопиченням
+	Clustered Bar	Смуги з групуванням
+	Stacked Bar	Смуги з накопиченням
+	Area	Області
+	Pie	Кругова
+	Doughnut	Кільцева
+	Scatter	Точкова
+	“{text}” ({row}, {series}) isn't a number.	«{text}» ({row}, {series}) — не число.
+	Category {n}	Категорія {n}
+	Series {n}	Ряд {n}
+	Type the categories down the side and a column of values per series.	Введіть категорії збоку та стовпець значень для кожного ряду.
+	Categories	Категорії
+	Series name	Назва ряду
+	Remove series	Видалити ряд
+	Remove row	Видалити рядок
+	Add Row	Додати рядок
+	Add Series	Додати ряд
+	Edit\nData	Редагувати\nдані
+	Change\nChart Type	Змінити тип\nдіаграми
 	Align Text	Вирівняти текст
 	Create Link	Створити зв'язок
 	Break Link	Розірвати зв'язок
@@ -1468,3 +1705,346 @@
 	English (United Kingdom)	Англійська (Велика Британія)
 	Polish	Польська
 	Do Not Check Spelling or Grammar	Не перевіряти правопис і граматику
+
+# Built-in file browser when the system file dialog is unavailable (#576)
+	Documents	Документи
+	Word document	Документ Word
+	All files	Усі файли
+	Recipient lists	Списки одержувачів
+	The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity.	Системне діалогове вікно файлів недоступне, тож WordCraft показує власне. Щоб отримати системне вікно, установіть портал вибору файлів (наприклад, xdg-desktop-portal-gtk) або zenity.
+	Up one level	На рівень вище
+	Home folder	Домашня тека
+	{name} wasn't found.	{name} не знайдено.
+	{name} already exists. Choose Save again to replace it.	{name} уже існує. Щоб замінити файл, виберіть «Зберегти» ще раз.
+	This folder can't be read: {error}	Не вдається прочитати цю теку: {error}
+	Showing the first {count} items.	Показано лише перші елементи: {count}.
+	File name:	Ім'я файлу:
+	Browse in WordCraft…	Огляд у WordCraft…
+	Open a file with WordCraft's own browser when the system file dialog doesn't appear.	Відкрити файл власним оглядачем WordCraft, коли системне діалогове вікно файлів не з'являється.
+	Hide White Space	Приховати порожній простір
+	All pages	Усі сторінки
+	Current page	Поточна сторінка
+	Selected pages	Вибрані сторінки
+	Custom range	Власний діапазон
+	All pages in the range	Усі сторінки діапазону
+	Odd pages only	Лише непарні сторінки
+	Even pages only	Лише парні сторінки
+	Copies	Копії
+	Collate copies	Розсортувати копії
+	Pages like 1-3, 5	Сторінки, наприклад 1-3, 5
+	{count} of {total} pages will print	Буде надруковано {count} зі сторінок: {total}
+	Save these pages as PDF…	Зберегти ці сторінки як PDF…
+	The printer, two-sided printing and pages per sheet are chosen in that dialog.	Принтер, двобічний друк і кількість сторінок на аркуші вибирають у цьому діалозі.
+	Previous Page	Попередня сторінка
+	Print to PDF	Друк у PDF
+	Add Shape	Додати фігуру
+	Change Colors	Змінити кольори
+	Change Layout	Змінити макет
+	Create Graphic	Створення графіки
+	Edit Items	Редагувати елементи
+	Layouts	Макети
+	Reset Graphic	Скинути графіку
+	SmartArt Design	Конструктор SmartArt
+	SmartArt Styles	Стилі SmartArt
+	Text Pane	Область тексту
+	List	Список
+	Process	Процес
+	Cycle	Цикл
+	Hierarchy	Ієрархія
+	Relationship	Зв’язок
+	Pyramid	Піраміда
+	Basic List	Простий список
+	Basic Process	Простий процес
+	Basic Cycle	Простий цикл
+	Basic Pyramid	Проста піраміда
+	Basic Radial	Проста радіальна
+	Basic Matrix	Проста матриця
+	Basic Venn	Проста діаграма Венна
+	Shows items of equal weight as blocks in rows.	Показує рівноцінні елементи як блоки в рядках.
+	Shows steps in order, left to right, with arrows between them.	Показує кроки по порядку, зліва направо, зі стрілками між ними.
+	Shows steps that repeat, around a circle.	Показує кроки, що повторюються, по колу.
+	Shows a tree: each item below the item it belongs to.	Показує дерево: кожен елемент під елементом, до якого він належить.
+	Shows parts that build on each other, largest at the bottom.	Показує частини, що спираються одна на одну, найбільша внизу.
+	Shows items around a central idea: the first item is the centre.	Показує елементи навколо центральної ідеї: перший елемент — центр.
+	Shows parts of a whole as quadrants.	Показує частини цілого як квадранти.
+	Shows overlapping ideas as overlapping circles.	Показує ідеї, що перетинаються, як кола, що перетинаються.
+	Accent {n}	Акцент {n}
+	Colorful	Різнокольоровий
+	Insert SmartArt	Вставити SmartArt
+	One line per item. Enter adds an item.	Один рядок на елемент. Enter додає елемент.
+	Add\nShape	Додати\nфігуру
+	Change\nColors	Змінити\nкольори
+	Reset\nGraphic	Скинути\nграфіку
+	Promote to Heading 1	Підвищити до заголовка 1
+	Demote to Body Text	Понизити до основного тексту
+	Move Up	Перемістити вгору
+	Move Down	Перемістити вниз
+	Collapse	Згорнути
+	Expand or Collapse Heading	Розгорнути або згорнути заголовок
+	Select Heading and Content	Виділити заголовок із вмістом
+	Show Level	Показати рівень
+	Show Level 1	Показати рівень 1
+	Show Level 2	Показати рівень 2
+	Show Level 3	Показати рівень 3
+	Show Level 4	Показати рівень 4
+	Show Level 5	Показати рівень 5
+	Show Level 6	Показати рівень 6
+	Show Level 7	Показати рівень 7
+	Show Level 8	Показати рівень 8
+	Show Level 9	Показати рівень 9
+	Show All Levels	Показати всі рівні
+	All Levels	Усі рівні
+	Show First Line Only	Лише перший рядок
+	Show Text Formatting	Показати форматування тексту
+	Close Outline View	Закрити режим плану
+	Outline State	Стан плану
+	Outlining	Структура
+	Outline Tools	Знаряддя плану
+	Close Outline\nView	Закрити\nрежим плану
+	A, B, C, …	A, B, C, …
+	Above the item	Над елементом
+	Accessed on	Дата звернення
+	Add New Source…	Додати нове джерело…
+	Add the chapter number	Додати номер розділу
+	Atmosphere	Атмосфера
+	Below the item	Під елементом
+	Book	Книга
+	Book title	Назва книги
+	Caption	Підпис
+	Caption Numbering	Нумерація підписів
+	Caption text	Текст підпису
+	Caption:	Підпис:
+	Chapter in a book	Розділ книги
+	Chapters begin at:	Розділи починаються з:
+	Collect entries from:	Брати елементи з:
+	Columns:	Стовпці:
+	Conference	Конференція
+	Conference paper	Доповідь конференції
+	Container Title	Назва видання
+	Create Source	Створити джерело
+	Cross-reference:	Перехресне посилання:
+	Custom Table of Contents…	Настроюваний зміст…
+	DOI	DOI
+	Day	День
+	Delete Label	Видалити мітку
+	Edit Source	Редагувати джерело
+	Edition	Видання
+	Edit…	Редагувати…
+	Entry marked.	Елемент позначено.
+	Example: {sample}	Приклад: {sample}
+	Figure	Рисунок
+	Film	Фільм
+	Heading styles (levels 1–{n})	Стилі заголовків (рівні 1–{n})
+	Heading {n}	Заголовок {n}
+	I, II, III, …	I, II, III, …
+	Include page numbers	Додавати номери сторінок
+	Indented	З відступом
+	Institution	Установа
+	Ionosphere	Іоносфера
+	Issue	Випуск
+	Journal	Журнал
+	Label:	Мітка:
+	Last, First; Last, First	Прізвище, Ім’я; Прізвище, Ім’я
+	Leave the label out of the caption	Не включати мітку в підпис
+	Letter headings	Літерні заголовки
+	Levels:	Рівні:
+	Link entries to their headings	Пов’язати елементи із заголовками
+	Made from the author and year when empty	Якщо порожньо, утворюється з автора й року
+	Magazine or newspaper article	Стаття в журналі чи газеті
+	Main entry:	Основний елемент:
+	Mark	Позначити
+	Mark All	Позначити всі
+	Mark Entry…	Позначити елемент…
+	Mark Index Entry	Позначити елемент покажчика
+	Mesosphere	Мезосфера
+	Month	Місяць
+	New Label	Нова мітка
+	New Label…	Нова мітка…
+	New…	Створити…
+	No sources yet.	Джерел ще немає.
+	Numbering…	Нумерація…
+	Options…	Параметри…
+	Other	Інше
+	Other styles and their TOC level:	Інші стилі та їхній рівень у змісті:
+	Outline levels	Рівні структури
+	Page number style	Стиль номера сторінки
+	Page numbers at the right margin	Номери сторінок біля правого поля
+	Page title	Назва сторінки
+	Pages of bookmark:	Сторінки закладки:
+	Periodical	Періодичне видання
+	Position:	Розташування:
+	Publisher	Видавець
+	Run-in	Суцільний
+	See	Див.
+	Separator:	Роздільник:
+	Show every bibliography field	Показати всі поля бібліографії
+	Site name	Назва сайту
+	Source Manager	Диспетчер джерел
+	Source type:	Тип джерела:
+	Sources in this document:	Джерела в цьому документі:
+	Styles:	Стилі:
+	Subentry:	Піделемент:
+	TC entry fields	Поля елементів TC
+	Tab leader:	Заповнювач табуляції:
+	Table of Contents Options	Параметри змісту
+	Table of Contents Styles	Стилі змісту
+	This page	Ця сторінка
+	Type:	Тип:
+	URL	URL
+	Volume	Том
+	Website	Вебсайт
+	Year	Рік
+	a, b, c, …	a, b, c, …
+	i, ii, iii, …	i, ii, iii, …
+	{n} entries marked.	Позначено елементів: {n}.
+	Lasso Select	Виділення ласо
+	Move Selected Ink	Перемістити виділений рукопис
+	Delete Selected Ink	Видалити виділений рукопис
+	Recolor Selected Ink	Змінити колір виділеного рукопису
+	Add Pen	Додати перо
+	Remove Pen	Вилучити перо
+	Ink to Shape	Рукопис у фігуру
+	Convert to Shapes	Перетворити на фігури
+	Ink Replay	Відтворити рукопис
+	Add\nPen	Додати\nперо
+	Rewind	На початок
+	Forward	Вперед
+	Stroke {n} of {total}	Штрих {n} з {total}
+	Use wildcards	Використовувати шаблони
+	Special	Спеціальні
+	Match prefix	Збіг префікса
+	Match suffix	Збіг суфікса
+	Ignore punctuation characters	Ігнорувати розділові знаки
+	Ignore white-space characters	Ігнорувати пробільні символи
+	Regular expressions	Регулярні вирази
+	Search Options	Параметри пошуку
+	Tab Character	Символ табуляції
+	Any Character	Будь-який символ
+	Any Digit	Будь-яка цифра
+	Any Letter	Будь-яка літера
+	Caret Character	Символ каретки
+	Section Character	Знак параграфа
+	Paragraph Character	Символ абзацу
+	Graphic	Графіка
+	Manual Line Break	Примусовий розрив рядка
+	Manual Page Break	Примусовий розрив сторінки
+	Section Break	Розрив розділу
+	White Space	Пробіл
+	Clipboard Contents	Вміст буфера обміну
+	Find What Text	Знайдений текст
+	Find What Expression	Знайдений вираз
+	Character in Range	Символ із діапазону
+	Beginning of Word	Початок слова
+	End of Word	Кінець слова
+	Expression	Вираз
+	Not	Не
+	Num Occurrences	Кількість повторень
+	Previous 1 or More	Попередній 1 або більше разів
+	0 or More Characters	0 або більше символів
+	Move with Text	Переміщувати з текстом
+	Fix Position on Page	Зафіксувати положення на сторінці
+
+# WordArt and connectors (#416).
+	WordArt Styles	Стилі WordArt
+	Text Fill	Заливка тексту
+	Text Outline	Контур тексту
+	Transform	Перетворення
+	No Fill	Без заливки
+	No Outline	Без контуру
+	Reflection	Відбиття
+	No Reflection	Без відбиття
+	No Transform	Без перетворення
+	Connect Shapes	З'єднати фігури
+	Straight Connector	Прямий з'єднувач
+	Straight Arrow Connector	Прямий з'єднувач зі стрілкою
+	Elbow Connector	Ламаний з'єднувач
+	Elbow Arrow Connector	Ламаний з'єднувач зі стрілкою
+	Curved Connector	Вигнутий з'єднувач
+	Curved Arrow Connector	Вигнутий з'єднувач зі стрілкою
+	Arch Up	Арка вгору
+	Arch Down	Арка вниз
+	Slant Up	Нахил угору
+	Slant Down	Нахил униз
+	Inflate	Роздуття
+	Deflate	Стиснення
+	Chevron Up	Шеврон угору
+	Chevron Down	Шеврон униз
+	Triangle Up	Трикутник угору
+	Triangle Down	Трикутник униз
+	Solid Accent	Суцільний акцент
+	Light with Outline	Світлий з контуром
+	Hollow	Порожнистий
+	Accent Gradient	Акцентний градієнт
+	Dark with Shadow	Темний із тінню
+	Soft Glow	М'яке світіння
+	Accent with Reflection	Акцент із відбиттям
+	Warm Gradient with Outline	Теплий градієнт із контуром
+	Add line numbering	Додати нумерацію рядків
+	Add to Document	Додати до документа
+	Address labels	Адресні етикетки
+	Arabic	Арабська
+	Auto	Авто
+	Automatically hyphenate document	Автоматично переносити слова в документі
+	Chinese (Simplified)	Китайська (спрощена)
+	Chinese (Traditional)	Китайська (традиційна)
+	Column:	Стовпець:
+	Count by:	Крок:
+	Czech	Чеська
+	Danish	Данська
+	Delivery address:	Адреса одержувача:
+	Detect language automatically	Визначати мову автоматично
+	Do not check spelling or grammar	Не перевіряти правопис і граматику
+	Dutch	Нідерландська
+	Envelope size:	Розмір конверта:
+	Estonian	Естонська
+	Finnish	Фінська
+	French (France)	Французька (Франція)
+	From text:	Від тексту:
+	Full page of the same label	Ціла сторінка однакових етикеток
+	German (Germany)	Німецька (Німеччина)
+	Greek	Грецька
+	Hebrew	Іврит
+	Hyphenate at:	Перенести після:
+	Hyphenate words in CAPS	Переносити слова з ВЕЛИКИХ ЛІТЕР
+	Hyphenation Options…	Параметри перенесення слів…
+	Hyphenation zone:	Зона перенесення:
+	Italian	Італійська
+	Japanese	Японська
+	Korean	Корейська
+	Limit consecutive hyphens to:	Обмежити кількість переносів поспіль:
+	Line Numbering Options…	Параметри нумерації рядків…
+	Manual Hyphenation	Ручне перенесення слів
+	Manual hyphenation is complete.	Ручне перенесення слів завершено.
+	Manual…	Вручну…
+	Mark selected text as:	Позначити виділений текст як:
+	New Document	Новий документ
+	No limit	Без обмеження
+	Norwegian (Bokmål)	Норвезька (букмол)
+	Numbering:	Нумерація:
+	Omit	Пропустити
+	One label per recipient	Одна етикетка на одержувача
+	Portuguese (Brazil)	Португальська (Бразилія)
+	Portuguese (Portugal)	Португальська (Португалія)
+	Return address labels	Етикетки зі зворотною адресою
+	Return address:	Зворотна адреса:
+	Row:	Рядок:
+	Russian	Російська
+	Serbian (Cyrillic)	Сербська (кирилиця)
+	Serbian (Latin)	Сербська (латиниця)
+	Set As Default	Зробити типовою
+	Shipping labels	Етикетки для відправлень
+	Single label	Одна етикетка
+	Spanish (Mexico)	Іспанська (Мексика)
+	Spanish (Spain)	Іспанська (Іспанія)
+	Swedish	Шведська
+	Turkish	Турецька
+	Ukrainian	Українська
+	{language} is now the document's default language.	{language} тепер типова мова документа.
+	Visual effects	Візуальні ефекти
+	Animation effects:	Ефекти анімації:
+	On	Увімкнено
+	Off	Вимкнено
+	Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.	Плавне прокручування й масштабування, а також поступова поява меню та кнопок. Якщо вибрано «Вимкнено», усі зміни відображаються одразу.
+	Your system has animation effects turned on.	У вашій системі ефекти анімації ввімкнено.
+	Your system has animation effects turned off.	У вашій системі ефекти анімації вимкнено.
+	Your system doesn't report an animation setting, so animation effects stay on.	Система не повідомляє про налаштування анімації, тому ефекти анімації залишаються ввімкненими.
diff --git a/crates/ui-egui/src/i18n/zh-hans.tsv b/crates/ui-egui/src/i18n/zh-hans.tsv
index b575f54a3a..c0678a6a49 100644
--- a/crates/ui-egui/src/i18n/zh-hans.tsv
+++ b/crates/ui-egui/src/i18n/zh-hans.tsv
@@ -60,12 +60,15 @@
 	Arrange\nAll	全部重排
 	Arrow	箭头
 	Artistic Effects	艺术效果
+	As you type	键入时
+	Asian text font:	亚洲文字字体：
 	Asian Typography	亚洲版式
 	Author	作者
 	AutoCorrect Options	自动更正选项
 	AutoFit	自动调整
 	AutoFit Contents	根据内容自动调整
 	AutoFit Window	根据窗口自动调整
+	AutoSave writes your changes to the file a moment after you stop typing.	停止键入片刻后，自动保存会将更改写入文件。
 	Automatic	自动
 	Automatic ({language})	自动（{language}）
 	Automatic follows your system's language. Menus and commands change; your documents don't.	“自动”跟随系统语言。菜单和命令会改变，文档内容不会改变。
@@ -76,13 +79,17 @@
 	AutoSave failed: {error}. Save the document to turn AutoSave back on.	自动保存失败：{error}。重新保存文档后将恢复自动保存。
 	Balloons	批注框
 	Bottom Margin	下边距
+	Centimeters	厘米
+	Check spelling as you type	键入时检查拼写
 	Click a border between two cells to merge them. Esc stops.	单击两个单元格之间的边框以合并它们。按 Esc 结束。
 	Bullet	项目符号
 	By author	按作者
 	Changed lines:	修订行：
 	Click level to modify:	单击要修改的级别：
+	Click to switch back to inserting	单击以切换回插入模式
 	Color only	仅颜色
 	Compress punctuation at the start of a line	压缩行首标点
+	Custom dictionary	自定义词典
 	Dark page (white text on black)	深色页面（黑底白字）
 	Drag a rectangle to draw a table, or a line across cells to split them. Esc stops.	拖出矩形以绘制表格，或拖出穿过单元格的线条以拆分单元格。按 Esc 结束。
 	Draw Table	绘制表格
@@ -93,10 +100,22 @@
 	Enter formatting for number:	输入编号的格式：
 	Follow number with:	编号之后：
 	Formatting	格式
+	Formatting marks	格式标记
+	Hidden text	隐藏文字
+	Ignore web and file addresses	忽略网址和文件路径
+	Ignore words in capitals	忽略全部大写的单词
+	Ignore words with numbers	忽略包含数字的单词
+	Inches	英寸
+	Formatting exceptions	格式例外
 	Include level number from:	包含的级别编号来自：
+	Initials:	缩写：
 	Ink	墨迹
 	Insertions and Deletions	插入和删除
 	Insertions:	插入内容：
+	Interface	界面
+	Interface language	界面语言
+	Inside:	内侧：
+	Latin text font:	拉丁文字字体：
 	Left border	左框线
 	Left Margin	左边距
 	Indents and Spacing	缩进和间距
@@ -104,13 +123,33 @@
 	Line breaking	断行
 	Link level to style:	将级别链接到样式：
 	List Definition	列表定义
+	Mark grammar errors as you type	键入时标记语法错误
+	Measurement units:	度量单位：
+	Millimeters	毫米
+	Mirror indents	对称缩进
 	More templates →	更多模板 →
+	New comments and tracked changes are recorded under this name and these initials.	新批注和修订将以此名称和缩写记录。
+	New word	新单词
 	No templates match your search.	没有与搜索匹配的模板。
+	No words yet. Add to Dictionary on a misspelled word puts it here.	还没有单词。对拼写错误的单词选择“添加到词典”会将其放在这里。
 	Nothing	无
 	Number alignment:	编号对齐方式：
 	Number format	编号格式
 	Number style for this level:	此级别的编号样式：
 	Outside border	外侧框线
+	Overtype	改写
+	Overtype (typing replaces the characters after the caret)	改写（键入的内容替换插入点后的字符）
+	Page display	页面显示
+	Paragraph marks	段落标记
+	Personalize	个性化
+	Picas	派卡
+	Points	磅
+	Print the page color	打印页面颜色
+	Printing	打印
+	Proofing language	校对语言
+	Recent documents to show:	显示的最近文档数：
+	Remove	移除
+	Outside:	外侧：
 	Reopen	重新打开
 	Restart list after:	重新开始列表的级别：
 	Right border	右框线
@@ -120,9 +159,9 @@
 	Distribute spacing	间距均匀分布
 	Offset (pt):	偏移量（磅）：
 	Phonetic Guide	拼音指南
-	Remove	删除
 	Right (vertical)	右对齐（竖排）
 	Ruby text:	拼音文字：
+	Save documents	保存文档
 	Search for templates	搜索模板
 	Show all revisions inline	以嵌入方式显示所有修订
 	Show documents with their colours inverted, like View › Switch Modes. Saving, printing and PDFs are unchanged.	像“视图 › 切换模式”一样以反转的颜色显示文档。保存、打印和 PDF 不受影响。
@@ -150,6 +189,11 @@
 	Border Painter	边框刷
 	Border\nPainter	边框刷
 	Borders	边框
+	Show the mini toolbar when text is selected	选择文本时显示浮动工具栏
+	Spaces	空格
+	Spelling	拼写
+	Spelling and grammar are checked in English (United States).	拼写和语法按英语（美国）检查。
+	Tab characters	制表符
 	Tab stop position:	制表位位置：
 	Default tab stops:	默认制表位：
 	Tab stops to be cleared:	要清除的制表位：
@@ -160,6 +204,10 @@
 	Set	设置
 	Page Border	页面边框线
 	Apply to:	应用于：
+	These marks show even when Show/Hide ¶ is off.	即使关闭“显示/隐藏 ¶”，这些标记也会显示。
+	Typing replaces selected text	键入内容替换所选文字
+	Update fields before printing	打印前更新域
+	Use the Insert key to switch overtype on and off	用 Insert 键切换改写模式
 	Whole document	整篇文档
 	This section	本节
 	Fill	填充
@@ -344,6 +392,7 @@
 	Export PDF	导出 PDF
 	Exported {path}	已导出 {path}
 	Extend Selection	扩展选定范围
+	Extend Selection by Units	按单位扩展选定范围
 	Field	域
 	File	文件
 	Find	查找
@@ -749,6 +798,9 @@
 	Show only comments and formatting in balloons	仅在批注框中显示批注和格式
 	Show revisions in balloons	在批注框中显示修订
 	Show rulers	显示标尺
+	Animation	动画
+	Animate the caret (it glides and fades)	为光标添加动画（平滑移动并淡入淡出）
+	On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off.	开启：输入或使用方向键时，光标平滑移动到新位置，闪烁时淡入淡出。关闭：光标直接跳转，闪烁时直接显示和隐藏。
 	Show the community button in the title bar	在标题栏中显示社区按钮
 	Show/Hide ¶	显示/隐藏 ¶
 	Show\nComments	显示批注
@@ -891,10 +943,10 @@
 	Wide	宽
 	Widow/Orphan Control	孤行控制
 	Widow/Orphan control	孤行控制
-	Wildcards (regex)	通配符（正则表达式）
 	Window	窗口
 	Word Count	字数统计
 	Word document (*.docx)	Word 文档 (*.docx)
+	Word XML Document (*.xml)	Word XML 文档 (*.xml)
 	Word Left	左移一个单词
 	Word Right	右移一个单词
 	WordArt	艺术字
@@ -1360,8 +1412,86 @@
 	Selected Fields	所选域
 	Edit Field…	编辑域…
 	Formatted	已设置格式
+	Deleted	已删除
 	Interface size:	界面大小：
 	Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate.	在系统显示缩放的基础上放大或缩小功能区、菜单和对话框。文档缩放单独设置。
+	Resize Table by Dragging	拖动调整表格大小
+	Print Markup	打印标记
+	Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text.	在 PDF、打印和图像中于每页旁显示批注和修订；在网页、Markdown 和文本末尾附上批注列表。
+
+# Compare / Combine, AutoCorrect Options and Restrict Editing (#412)
+	1. Formatting restrictions	1. 格式限制
+	2. Editing restrictions	2. 编辑限制
+	3. Start enforcement	3. 启动保护
+	<< Less	<< 更少
+	Another file	其他文件
+	Apply as you type	键入时应用
+	AutoCorrect	自动更正
+	AutoFormat As You Type	键入时自动套用格式
+	Automatic bulleted lists	自动项目符号列表
+	Automatic numbered lists	自动编号列表
+	Border lines	边框线
+	Capitalize first letter of sentences	句首字母大写
+	Capitalize first letter of table cells	表格单元格首字母大写
+	Capitalize names of days	星期名称首字母大写
+	Case changes	大小写更改
+	Character level	字符级
+	Checked styles are allowed:	选中的样式允许使用:
+	Combine Documents	合并文档
+	Compare Documents	比较文档
+	Compared: {changes} changes	已比较: {changes} 处更改
+	Comparing with another file needs the desktop app.	与其他文件比较需要桌面版应用。
+	Comparison settings	比较设置
+	Don't capitalize after:	不在以下内容后大写:
+	Editing in this document is restricted.	此文档的编辑受到限制。
+	Every change is recorded as a tracked change.	每处更改都会作为修订记录。
+	Everyone	每个人
+	Exceptions (optional)	例外项(可选)
+	Exceptions…	例外项…
+	Fields	域
+	Filling in forms	填写窗体
+	Find Next Editable Region	查找下一个可编辑区域
+	Footnotes and endnotes	脚注和尾注
+	Formatting, case changes, white space and tables are compared; the other settings are kept for later.	会比较格式、大小写、空白和表格；其他设置留待以后支持。
+	Fractions (1/2) as fraction characters (½)	分数 (1/2) 替换为分数字符 (½)
+	Headers and footers	页眉和页脚
+	Hyphens (--) as dashes (—)	连字符 (--) 替换为破折号 (—)
+	In equations, typing a name after a backslash replaces it with its symbol.	在公式中，在反斜杠后键入名称会将其替换为相应符号。
+	Internet addresses as links	Internet 地址替换为链接
+	Label changes with:	修订者标记:
+	Limit formatting to a selection of styles	将格式限制为所选样式
+	Math AutoCorrect	数学符号自动更正
+	More >>	更多 >>
+	Moves	移动
+	New document	新文档
+	No changes (read only)	不允许任何更改(只读)
+	Only allow this kind of editing:	仅允许此类编辑:
+	Only comments can be added, except in regions marked editable.	只能添加批注，标记为可编辑的区域除外。
+	Only form fields can be filled in.	只能填写窗体域。
+	Only the allowed styles can be applied.	只能应用允许的样式。
+	Ordinals (1st) as superscript	序数 (1st) 替换为上标
+	Original document	原文档
+	This password type isn't supported.	不支持此密码类型。
+	Replace as you type	键入时自动替换
+	Replace text as you type	键入时自动替换文本
+	Replace:	替换:
+	Revised document	修订的文档
+	Select text, then tick who can still edit it.	选择文本，然后勾选仍可编辑它的人。
+	Settings…	设置…
+	Show changes at:	显示修订的级别:
+	Show changes in:	修订的显示位置:
+	Smart quotes instead of straight quotes	以弯引号替换直引号
+	Start Enforcing Protection	启动强制保护
+	Stop Protection	停止保护
+	Text boxes	文本框
+	The document is read only, except for regions marked editable.	文档为只读，标记为可编辑的区域除外。
+	The password is optional; without it anyone can stop the protection.	密码是可选的；没有密码，任何人都可以停止保护。
+	This document	此文档
+	Tracked changes	修订
+	Type the password to stop the protection.	键入密码以停止保护。
+	White space	空白
+	With:	替换为:
+	Word level	字词级
 	In Line with Text	与文字同行
 	Square	四周型
 	Through	穿越型
@@ -1408,6 +1538,36 @@
 	New Group	新建组
 	Rename…	重命名…
 	Ribbon and Quick Access Toolbar:	功能区和快速访问工具栏：
+	Add Font…	添加字体…
+	Added Fonts	已添加的字体
+	Remove Added Font	删除已添加的字体
+	Recent Colors	最近使用的颜色
+	More Colors…	其他颜色…
+	Standard	标准
+	Current	当前
+	Colors:	颜色:
+	Color model:	颜色模式:
+	Red:	红色:
+	Green:	绿色:
+	Blue:	蓝色:
+	Hue:	色调:
+	Sat:	饱和度:
+	Lum:	亮度:
+	Hex:	十六进制:
+	Accessibility Pane	辅助功能窗格
+	Alt Text Pane	替代文字窗格
+	Alt\nText	替代\n文字
+	View Alt Text…	查看替代文字…
+	Mark as decorative	标记为装饰性
+	Title:	标题：
+	Errors ({n})	错误 ({n})
+	Warnings ({n})	警告 ({n})
+	Tips ({n})	提示 ({n})
+	No accessibility issues found.	未发现辅助功能问题。
+	Describe what this object shows, for people who can't see it.	请为看不见的人描述此对象显示的内容。
+	Decorative objects only add visual interest: screen readers skip them.	装饰性对象仅增添视觉效果：屏幕阅读器会跳过它们。
+	Describe what this table shows, for people who can't see it.	请为看不见的人描述此表格显示的内容。
+	Select a picture, shape, chart or table to describe it.	选择图片、形状、图表或表格以添加描述。
 	Document Grid	文档网格
 	No grid	无网格
 	Lines only	仅行
@@ -1417,6 +1577,39 @@
 	Lines per page:	每页行数：
 	Moved from	移动自
 	Moved to	移动到
+	Developer	开发工具
+	Controls	控件
+	Rich Text Content Control	格式文本内容控件
+	Plain Text Content Control	纯文本内容控件
+	Picture Content Control	图片内容控件
+	Building Block Gallery Content Control	构建基块库内容控件
+	Check Box Content Control	复选框内容控件
+	Combo Box Content Control	组合框内容控件
+	Drop-Down List Content Control	下拉列表内容控件
+	Date Picker Content Control	日期选取器内容控件
+	Repeating Section Content Control	重复节内容控件
+	Design Mode	设计模式
+	Content Control at Selection	所选位置的内容控件
+	Toggle Check Box	切换复选框
+	Choose List Item	选择列表项
+	Set Date	设置日期
+	Remove Content Control	删除内容控件
+	Content Control Properties	内容控件属性
+	Title	标题
+	Tag	标记
+	Placeholder text	占位符文本
+	Can't be deleted	无法删除
+	Contents can't be edited	无法编辑内容
+	Remove the control once edited	编辑后删除控件
+	Allow line breaks	允许换行
+	Date format	日期格式
+	Checked symbol	选中符号
+	Unchecked symbol	未选中符号
+	List entries	列表项
+	Display text	显示文本
+	Value	值
+	Today	今天
+	Put the caret in a content control first.	请先将光标放在内容控件中。
 	Right-to-Left Table	从右向左表格
 	Right-to-Left Section	从右向左节
 	Table direction:	表格方向：
@@ -1444,6 +1637,50 @@
 	Enlarge symbol	增大圈号
 	Enclosure	圈号
 	Circle	圆形
+	Templates	模板
+	Templates and Add-ins	模板和加载项
+	Attach Template	附加模板
+	Detach Template	分离模板
+	Automatically Update Document Styles	自动更新文档样式
+	Update Styles from Template	从模板更新样式
+	Organizer	管理器
+	Copy Styles	复制样式
+	Rename Style	重命名样式
+	Document template:	文档模板：
+	Attach…	附加…
+	Automatically update document styles	自动更新文档样式
+	Organizer…	管理器…
+	Change Chart Type	更改图表类型
+	Chart Design	图表设计
+	Type	类型
+	Edit Data	编辑数据
+	Chart Title	图表标题
+	Chart Layouts	图表布局
+	Add Chart Element	添加图表元素
+	Legend	图例
+	Data Labels	数据标签
+	Above Chart	图表上方
+	Insert Chart	插入图表
+	Clustered Column	簇状柱形图
+	Stacked Column	堆积柱形图
+	Clustered Bar	簇状条形图
+	Stacked Bar	堆积条形图
+	Area	面积图
+	Pie	饼图
+	Doughnut	圆环图
+	Scatter	散点图
+	“{text}” ({row}, {series}) isn't a number.	“{text}”（{row}，{series}）不是数字。
+	Category {n}	类别 {n}
+	Series {n}	系列 {n}
+	Type the categories down the side and a column of values per series.	在左侧输入类别，每个系列输入一列数值。
+	Categories	类别
+	Series name	系列名称
+	Remove series	删除系列
+	Remove row	删除行
+	Add Row	添加行
+	Add Series	添加系列
+	Edit\nData	编辑\n数据
+	Change\nChart Type	更改\n图表类型
 	Align Text	对齐文本
 	Create Link	创建链接
 	Break Link	断开链接
@@ -1468,3 +1705,346 @@
 	English (United Kingdom)	英语（英国）
 	Polish	波兰语
 	Do Not Check Spelling or Grammar	不检查拼写和语法
+
+# Built-in file browser when the system file dialog is unavailable (#576)
+	Documents	文档
+	Word document	Word 文档
+	All files	所有文件
+	Recipient lists	收件人列表
+	The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity.	系统文件对话框不可用，因此 WordCraft 显示自己的对话框。要使用系统对话框，请安装文件选择器门户（例如 xdg-desktop-portal-gtk）或 zenity。
+	Up one level	向上一级
+	Home folder	主文件夹
+	{name} wasn't found.	未找到 {name}。
+	{name} already exists. Choose Save again to replace it.	{name} 已存在。再次选择“保存”即可替换它。
+	This folder can't be read: {error}	无法读取此文件夹：{error}
+	Showing the first {count} items.	仅显示前 {count} 项。
+	File name:	文件名:
+	Browse in WordCraft…	在 WordCraft 中浏览…
+	Open a file with WordCraft's own browser when the system file dialog doesn't appear.	当系统文件对话框没有出现时，使用 WordCraft 自带的浏览器打开文件。
+	Hide White Space	隐藏空白
+	All pages	所有页面
+	Current page	当前页
+	Selected pages	所选页面
+	Custom range	自定义范围
+	All pages in the range	范围内的所有页面
+	Odd pages only	仅奇数页
+	Even pages only	仅偶数页
+	Copies	份数
+	Collate copies	逐份打印
+	Pages like 1-3, 5	页码,如 1-3, 5
+	{count} of {total} pages will print	将打印 {total} 页中的 {count} 页
+	Save these pages as PDF…	将这些页面另存为 PDF…
+	The printer, two-sided printing and pages per sheet are chosen in that dialog.	打印机、双面打印和每张页数在该对话框中选择。
+	Previous Page	上一页
+	Print to PDF	打印到 PDF
+	Add Shape	添加形状
+	Change Colors	更改颜色
+	Change Layout	更改布局
+	Create Graphic	创建图形
+	Edit Items	编辑项目
+	Layouts	布局
+	Reset Graphic	重设图形
+	SmartArt Design	SmartArt 设计
+	SmartArt Styles	SmartArt 样式
+	Text Pane	文本窗格
+	List	列表
+	Process	流程
+	Cycle	循环
+	Hierarchy	层次结构
+	Relationship	关系
+	Pyramid	棱锥图
+	Basic List	基本列表
+	Basic Process	基本流程
+	Basic Cycle	基本循环
+	Basic Pyramid	基本棱锥图
+	Basic Radial	基本射线图
+	Basic Matrix	基本矩阵
+	Basic Venn	基本维恩图
+	Shows items of equal weight as blocks in rows.	将同等重要的项目显示为成行排列的方块。
+	Shows steps in order, left to right, with arrows between them.	按从左到右的顺序显示步骤，步骤之间用箭头连接。
+	Shows steps that repeat, around a circle.	沿圆周显示重复的步骤。
+	Shows a tree: each item below the item it belongs to.	显示树形结构：每个项目位于其所属项目的下方。
+	Shows parts that build on each other, largest at the bottom.	显示层层递进的部分，最大的在底部。
+	Shows items around a central idea: the first item is the centre.	围绕中心思想显示项目：第一个项目位于中心。
+	Shows parts of a whole as quadrants.	将整体的各部分显示为象限。
+	Shows overlapping ideas as overlapping circles.	将相互重叠的观点显示为重叠的圆。
+	Accent {n}	着色 {n}
+	Colorful	彩色
+	Insert SmartArt	插入 SmartArt
+	One line per item. Enter adds an item.	每个项目一行。按 Enter 添加项目。
+	Add\nShape	添加\n形状
+	Change\nColors	更改\n颜色
+	Reset\nGraphic	重设\n图形
+	Promote to Heading 1	提升至标题 1
+	Demote to Body Text	降级为正文文本
+	Move Up	上移
+	Move Down	下移
+	Collapse	折叠
+	Expand or Collapse Heading	展开或折叠标题
+	Select Heading and Content	选择标题及其内容
+	Show Level	显示级别
+	Show Level 1	显示 1 级
+	Show Level 2	显示 2 级
+	Show Level 3	显示 3 级
+	Show Level 4	显示 4 级
+	Show Level 5	显示 5 级
+	Show Level 6	显示 6 级
+	Show Level 7	显示 7 级
+	Show Level 8	显示 8 级
+	Show Level 9	显示 9 级
+	Show All Levels	显示所有级别
+	All Levels	所有级别
+	Show First Line Only	仅显示首行
+	Show Text Formatting	显示文本格式
+	Close Outline View	关闭大纲视图
+	Outline State	大纲状态
+	Outlining	大纲显示
+	Outline Tools	大纲工具
+	Close Outline\nView	关闭\n大纲视图
+	A, B, C, …	A, B, C, …
+	Above the item	项目上方
+	Accessed on	访问日期
+	Add New Source…	添加新源…
+	Add the chapter number	添加章节编号
+	Atmosphere	大气
+	Below the item	项目下方
+	Book	书籍
+	Book title	书名
+	Caption	题注
+	Caption Numbering	题注编号
+	Caption text	题注文字
+	Caption:	题注：
+	Chapter in a book	书籍章节
+	Chapters begin at:	章节起始于：
+	Collect entries from:	条目来源：
+	Columns:	栏数：
+	Conference	会议
+	Conference paper	会议论文
+	Container Title	载体标题
+	Create Source	创建源
+	Cross-reference:	交叉引用：
+	Custom Table of Contents…	自定义目录…
+	DOI	DOI
+	Day	日
+	Delete Label	删除标签
+	Edit Source	编辑源
+	Edition	版次
+	Edit…	编辑…
+	Entry marked.	已标记条目。
+	Example: {sample}	示例：{sample}
+	Figure	图
+	Film	电影
+	Heading styles (levels 1–{n})	标题样式（级别 1–{n}）
+	Heading {n}	标题 {n}
+	I, II, III, …	I, II, III, …
+	Include page numbers	包含页码
+	Indented	缩进式
+	Institution	机构
+	Ionosphere	电离层
+	Issue	期号
+	Journal	期刊
+	Label:	标签：
+	Last, First; Last, First	姓, 名; 姓, 名
+	Leave the label out of the caption	题注中不含标签
+	Letter headings	字母标题
+	Levels:	级别：
+	Link entries to their headings	将条目链接到标题
+	Made from the author and year when empty	留空时由作者和年份生成
+	Magazine or newspaper article	杂志或报纸文章
+	Main entry:	主索引项：
+	Mark	标记
+	Mark All	全部标记
+	Mark Entry…	标记条目…
+	Mark Index Entry	标记索引项
+	Mesosphere	中间层
+	Month	月
+	New Label	新建标签
+	New Label…	新建标签…
+	New…	新建…
+	No sources yet.	尚无源。
+	Numbering…	编号…
+	Options…	选项…
+	Other	其他
+	Other styles and their TOC level:	其他样式及其目录级别：
+	Outline levels	大纲级别
+	Page number style	页码样式
+	Page numbers at the right margin	页码靠右边距
+	Page title	页面标题
+	Pages of bookmark:	书签所在页：
+	Periodical	期刊名
+	Position:	位置：
+	Publisher	出版商
+	Run-in	接排式
+	See	参见
+	Separator:	分隔符：
+	Show every bibliography field	显示所有书目字段
+	Site name	网站名称
+	Source Manager	源管理器
+	Source type:	源类型：
+	Sources in this document:	本文档中的源：
+	Styles:	样式：
+	Subentry:	次索引项：
+	TC entry fields	TC 条目域
+	Tab leader:	制表符前导符：
+	Table of Contents Options	目录选项
+	Table of Contents Styles	目录样式
+	This page	当前页
+	Type:	类型：
+	URL	URL
+	Volume	卷
+	Website	网站
+	Year	年份
+	a, b, c, …	a, b, c, …
+	i, ii, iii, …	i, ii, iii, …
+	{n} entries marked.	已标记 {n} 个条目。
+	Lasso Select	套索选择
+	Move Selected Ink	移动所选墨迹
+	Delete Selected Ink	删除所选墨迹
+	Recolor Selected Ink	更改所选墨迹颜色
+	Add Pen	添加笔
+	Remove Pen	删除笔
+	Ink to Shape	墨迹转形状
+	Convert to Shapes	转换为形状
+	Ink Replay	墨迹重播
+	Add\nPen	添加笔
+	Rewind	倒回
+	Forward	前进
+	Stroke {n} of {total}	第 {n} 笔，共 {total} 笔
+	Use wildcards	使用通配符
+	Special	特殊字符
+	Match prefix	匹配前缀
+	Match suffix	匹配后缀
+	Ignore punctuation characters	忽略标点符号
+	Ignore white-space characters	忽略空白字符
+	Regular expressions	正则表达式
+	Search Options	搜索选项
+	Tab Character	制表符字符
+	Any Character	任意字符
+	Any Digit	任意数字
+	Any Letter	任意字母
+	Caret Character	脱字号
+	Section Character	章节号
+	Paragraph Character	段落符号
+	Graphic	图形
+	Manual Line Break	手动换行符
+	Manual Page Break	手动分页符
+	Section Break	分节符
+	White Space	空白
+	Clipboard Contents	剪贴板内容
+	Find What Text	查找到的文本
+	Find What Expression	查找到的表达式
+	Character in Range	范围内的字符
+	Beginning of Word	单词开头
+	End of Word	单词结尾
+	Expression	表达式
+	Not	非
+	Num Occurrences	出现次数
+	Previous 1 or More	前一项 1 次或多次
+	0 or More Characters	0 个或多个字符
+	Move with Text	随文字移动
+	Fix Position on Page	在页面上的位置固定
+
+# WordArt and connectors (#416).
+	WordArt Styles	艺术字样式
+	Text Fill	文本填充
+	Text Outline	文本轮廓
+	Transform	转换
+	No Fill	无填充
+	No Outline	无轮廓
+	Reflection	映像
+	No Reflection	无映像
+	No Transform	无转换
+	Connect Shapes	连接形状
+	Straight Connector	直线连接符
+	Straight Arrow Connector	直线箭头连接符
+	Elbow Connector	肘形连接符
+	Elbow Arrow Connector	肘形箭头连接符
+	Curved Connector	曲线连接符
+	Curved Arrow Connector	曲线箭头连接符
+	Arch Up	上弯弧
+	Arch Down	下弯弧
+	Slant Up	上斜
+	Slant Down	下斜
+	Inflate	膨胀
+	Deflate	收缩
+	Chevron Up	上V形
+	Chevron Down	下V形
+	Triangle Up	正三角
+	Triangle Down	倒三角
+	Solid Accent	纯色强调
+	Light with Outline	浅色带轮廓
+	Hollow	空心
+	Accent Gradient	强调渐变
+	Dark with Shadow	深色带阴影
+	Soft Glow	柔和发光
+	Accent with Reflection	强调带映像
+	Warm Gradient with Outline	暖色渐变带轮廓
+	Add line numbering	添加行号
+	Add to Document	添加到文档
+	Address labels	地址标签
+	Arabic	阿拉伯语
+	Auto	自动
+	Automatically hyphenate document	自动断字
+	Chinese (Simplified)	中文（简体）
+	Chinese (Traditional)	中文（繁体）
+	Column:	列：
+	Count by:	行号间隔：
+	Czech	捷克语
+	Danish	丹麦语
+	Delivery address:	收信人地址：
+	Detect language automatically	自动检测语言
+	Do not check spelling or grammar	不检查拼写或语法
+	Dutch	荷兰语
+	Envelope size:	信封尺寸：
+	Estonian	爱沙尼亚语
+	Finnish	芬兰语
+	French (France)	法语（法国）
+	From text:	距正文：
+	Full page of the same label	同一标签的整页
+	German (Germany)	德语（德国）
+	Greek	希腊语
+	Hebrew	希伯来语
+	Hyphenate at:	断字位置：
+	Hyphenate words in CAPS	大写单词断字
+	Hyphenation Options…	断字选项…
+	Hyphenation zone:	断字区：
+	Italian	意大利语
+	Japanese	日语
+	Korean	韩语
+	Limit consecutive hyphens to:	连续断字数限制：
+	Line Numbering Options…	行号选项…
+	Manual Hyphenation	手动断字
+	Manual hyphenation is complete.	手动断字已完成。
+	Manual…	手动…
+	Mark selected text as:	将所选文字标记为：
+	New Document	新建文档
+	No limit	无限制
+	Norwegian (Bokmål)	挪威语（书面挪威语）
+	Numbering:	编号：
+	Omit	省略
+	One label per recipient	每位收件人一个标签
+	Portuguese (Brazil)	葡萄牙语（巴西）
+	Portuguese (Portugal)	葡萄牙语（葡萄牙）
+	Return address labels	回信地址标签
+	Return address:	寄信人地址：
+	Row:	行：
+	Russian	俄语
+	Serbian (Cyrillic)	塞尔维亚语（西里尔文）
+	Serbian (Latin)	塞尔维亚语（拉丁文）
+	Set As Default	设为默认值
+	Shipping labels	运输标签
+	Single label	单个标签
+	Spanish (Mexico)	西班牙语（墨西哥）
+	Spanish (Spain)	西班牙语（西班牙）
+	Swedish	瑞典语
+	Turkish	土耳其语
+	Ukrainian	乌克兰语
+	{language} is now the document's default language.	{language} 现在是此文档的默认语言。
+	Visual effects	视觉效果
+	Animation effects:	动画效果：
+	On	开
+	Off	关
+	Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.	平滑滚动和缩放，以及菜单和按钮的淡入效果。选择“关”后，所有更改会立即显示。
+	Your system has animation effects turned on.	系统已打开动画效果。
+	Your system has animation effects turned off.	系统已关闭动画效果。
+	Your system doesn't report an animation setting, so animation effects stay on.	系统未提供动画设置，因此动画效果保持打开。
diff --git a/crates/ui-egui/src/i18n/zh-hant.tsv b/crates/ui-egui/src/i18n/zh-hant.tsv
index bc2a5ec03e..aaea49470b 100644
--- a/crates/ui-egui/src/i18n/zh-hant.tsv
+++ b/crates/ui-egui/src/i18n/zh-hant.tsv
@@ -49,12 +49,15 @@
 	Arrange\nAll	全部排列
 	Arrow	箭號
 	Artistic Effects	美術效果
+	As you type	輸入時
+	Asian text font:	亞洲文字字型：
 	Asian Typography	亞洲版式
 	Author	作者
 	AutoCorrect Options	自動校正選項
 	AutoFit	自動調整
 	AutoFit Contents	依內容自動調整
 	AutoFit Window	依視窗自動調整
+	AutoSave writes your changes to the file a moment after you stop typing.	停止輸入片刻後，自動儲存會將變更寫入檔案。
 	Automatic	自動
 	Automatic ({language})	自動（{language}）
 	Automatic follows your system's language. Menus and commands change; your documents don't.	「自動」會跟隨系統語言。功能表與命令會改變，文件內容不會改變。
@@ -65,13 +68,17 @@
 	AutoSave failed: {error}. Save the document to turn AutoSave back on.	自動儲存失敗：{error}。重新儲存文件後將恢復自動儲存。
 	Balloons	註解方塊
 	Bottom Margin	下邊界
+	Centimeters	公分
+	Check spelling as you type	輸入時檢查拼字
 	Click a border between two cells to merge them. Esc stops.	按一下兩個儲存格之間的框線以合併它們。按 Esc 結束。
 	Bullet	項目符號
 	By author	依作者
 	Changed lines:	修訂行：
 	Click level to modify:	按一下要修改的層級：
+	Click to switch back to inserting	按一下以切換回插入模式
 	Color only	僅色彩
 	Compress punctuation at the start of a line	壓縮行首標點
+	Custom dictionary	自訂字典
 	Dark page (white text on black)	深色頁面（黑底白字）
 	Drag a rectangle to draw a table, or a line across cells to split them. Esc stops.	拖出矩形以繪製表格，或拖出穿過儲存格的線條以分割儲存格。按 Esc 結束。
 	Draw Table	繪製表格
@@ -82,10 +89,22 @@
 	Enter formatting for number:	輸入編號的格式：
 	Follow number with:	編號之後：
 	Formatting	格式設定
+	Formatting marks	格式化標記
+	Hidden text	隱藏文字
+	Ignore web and file addresses	忽略網址和檔案路徑
+	Ignore words in capitals	忽略全部大寫的單字
+	Ignore words with numbers	忽略包含數字的單字
+	Inches	英寸
+	Formatting exceptions	格式例外
 	Include level number from:	包含的層級編號來自：
+	Initials:	縮寫：
 	Ink	筆跡
 	Insertions and Deletions	插入和刪除
 	Insertions:	插入內容：
+	Interface	介面
+	Interface language	介面語言
+	Inside:	內側：
+	Latin text font:	拉丁文字字型：
 	Left border	左框線
 	Left Margin	左邊界
 	Indents and Spacing	縮排和間距
@@ -93,13 +112,33 @@
 	Line breaking	斷行
 	Link level to style:	將層級連結到樣式：
 	List Definition	清單定義
+	Mark grammar errors as you type	輸入時標示文法錯誤
+	Measurement units:	度量單位：
+	Millimeters	公釐
+	Mirror indents	對稱縮排
 	More templates →	更多範本 →
+	New comments and tracked changes are recorded under this name and these initials.	新的註解和追蹤修訂會以此名稱和縮寫記錄。
+	New word	新單字
 	No templates match your search.	沒有符合搜尋的範本。
+	No words yet. Add to Dictionary on a misspelled word puts it here.	還沒有單字。對拼字錯誤的單字選擇「新增至字典」會將它放在這裡。
 	Nothing	無
 	Number alignment:	編號對齊方式：
 	Number format	編號格式
 	Number style for this level:	此層級的編號樣式：
 	Outside border	外側框線
+	Overtype	取代
+	Overtype (typing replaces the characters after the caret)	取代（輸入的內容會取代插入點後的字元）
+	Page display	頁面顯示
+	Paragraph marks	段落標記
+	Personalize	個人化
+	Picas	派卡
+	Points	點
+	Print the page color	列印頁面色彩
+	Printing	列印
+	Proofing language	校訂語言
+	Recent documents to show:	顯示的最近文件數：
+	Remove	移除
+	Outside:	外側：
 	Reopen	重新開啟
 	Restart list after:	重新開始清單的層級：
 	Right border	右框線
@@ -109,9 +148,9 @@
 	Distribute spacing	間距平均分散
 	Offset (pt):	位移（點）：
 	Phonetic Guide	注音標示
-	Remove	移除
 	Right (vertical)	靠右（直書）
 	Ruby text:	注音文字：
+	Save documents	儲存文件
 	Search for templates	搜尋範本
 	Show all revisions inline	以內嵌方式顯示所有修訂
 	Show documents with their colours inverted, like View › Switch Modes. Saving, printing and PDFs are unchanged.	像「檢視 › 切換模式」一樣以反轉的色彩顯示文件。儲存、列印和 PDF 不受影響。
@@ -139,6 +178,11 @@
 	Border Painter	框線複製
 	Border\nPainter	框線複製
 	Borders	框線
+	Show the mini toolbar when text is selected	選取文字時顯示迷你工具列
+	Spaces	空格
+	Spelling	拼字
+	Spelling and grammar are checked in English (United States).	拼字和文法依英文（美國）檢查。
+	Tab characters	定位字元
 	Tab stop position:	定位點位置：
 	Default tab stops:	預設定位點間距：
 	Tab stops to be cleared:	要清除的定位點：
@@ -149,6 +193,10 @@
 	Set	設定
 	Page Border	頁面框線設定
 	Apply to:	套用至：
+	These marks show even when Show/Hide ¶ is off.	即使關閉「顯示/隱藏 ¶」，這些標記也會顯示。
+	Typing replaces selected text	輸入的內容取代選取的文字
+	Update fields before printing	列印前更新功能變數
+	Use the Insert key to switch overtype on and off	使用 Insert 鍵切換取代模式
 	Whole document	整份文件
 	This section	本節
 	Fill	填滿
@@ -333,6 +381,7 @@
 	Export PDF	匯出 PDF
 	Exported {path}	已匯出 {path}
 	Extend Selection	擴大選取範圍
+	Extend Selection by Units	按單位擴大選取範圍
 	Field	功能變數
 	File	檔案
 	Find	尋找
@@ -738,6 +787,9 @@
 	Show only comments and formatting in balloons	僅在註解方塊中顯示註解和格式設定
 	Show revisions in balloons	在註解方塊中顯示修訂
 	Show rulers	顯示尺規
+	Animation	動畫
+	Animate the caret (it glides and fades)	為游標加上動畫（平滑移動並淡入淡出）
+	On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off.	開啟：輸入或使用方向鍵時，游標會平滑移動到新位置，閃爍時淡入淡出。關閉：游標直接跳到新位置，閃爍時直接顯示和隱藏。
 	Show the community button in the title bar	在標題列中顯示社群按鈕
 	Show/Hide ¶	顯示/隱藏 ¶
 	Show\nComments	顯示註解
@@ -880,10 +932,10 @@
 	Wide	寬
 	Widow/Orphan Control	遺留字串控制
 	Widow/Orphan control	遺留字串控制
-	Wildcards (regex)	萬用字元（規則運算式）
 	Window	視窗
 	Word Count	字數統計
 	Word document (*.docx)	Word 文件 (*.docx)
+	Word XML Document (*.xml)	Word XML 文件 (*.xml)
 	Word Left	左移一個單字
 	Word Right	右移一個單字
 	WordArt	文字藝術師
@@ -1349,8 +1401,86 @@
 	Selected Fields	選取的功能變數
 	Edit Field…	編輯功能變數…
 	Formatted	已設定格式
+	Deleted	已刪除
 	Interface size:	介面大小：
 	Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate.	在系統顯示縮放的基礎上放大或縮小功能區、功能表與對話方塊。文件縮放另行設定。
+	Resize Table by Dragging	拖曳調整表格大小
+	Print Markup	列印標記
+	Comments beside each page and tracked changes in PDFs, prints and images; a comment list at the end of web pages, Markdown and text.	在 PDF、列印和影像中於每頁旁顯示註解和修訂；在網頁、Markdown 和文字末尾附上註解清單。
+
+# Compare / Combine, AutoCorrect Options and Restrict Editing (#412)
+	1. Formatting restrictions	1. 格式設定限制
+	2. Editing restrictions	2. 編輯限制
+	3. Start enforcement	3. 開始保護
+	<< Less	<< 較少
+	Another file	其他檔案
+	Apply as you type	輸入時套用
+	AutoCorrect	自動校正
+	AutoFormat As You Type	輸入時自動格式設定
+	Automatic bulleted lists	自動項目符號清單
+	Automatic numbered lists	自動編號清單
+	Border lines	框線
+	Capitalize first letter of sentences	句首字母大寫
+	Capitalize first letter of table cells	表格儲存格首字母大寫
+	Capitalize names of days	星期名稱首字母大寫
+	Case changes	大小寫變更
+	Character level	字元層級
+	Checked styles are allowed:	勾選的樣式可以使用:
+	Combine Documents	合併文件
+	Compare Documents	比較文件
+	Compared: {changes} changes	已比較: {changes} 處變更
+	Comparing with another file needs the desktop app.	與其他檔案比較需要桌面版應用程式。
+	Comparison settings	比較設定
+	Don't capitalize after:	不在以下內容後大寫:
+	Editing in this document is restricted.	此文件的編輯受到限制。
+	Every change is recorded as a tracked change.	每項變更都會記錄為追蹤修訂。
+	Everyone	所有人
+	Exceptions (optional)	例外狀況 (選用)
+	Exceptions…	例外狀況…
+	Fields	功能變數
+	Filling in forms	填寫表單
+	Find Next Editable Region	尋找下一個可編輯區域
+	Footnotes and endnotes	註腳和章節附註
+	Formatting, case changes, white space and tables are compared; the other settings are kept for later.	會比較格式、大小寫、空白和表格；其他設定留待日後支援。
+	Fractions (1/2) as fraction characters (½)	分數 (1/2) 取代為分數字元 (½)
+	Headers and footers	頁首及頁尾
+	Hyphens (--) as dashes (—)	連字號 (--) 取代為破折號 (—)
+	In equations, typing a name after a backslash replaces it with its symbol.	在方程式中，於反斜線後輸入名稱會取代為對應符號。
+	Internet addresses as links	網際網路位址取代為連結
+	Label changes with:	變更標記為:
+	Limit formatting to a selection of styles	限制格式為選取的樣式
+	Math AutoCorrect	數學自動校正
+	More >>	更多 >>
+	Moves	移動
+	New document	新文件
+	No changes (read only)	不允許任何變更 (唯讀)
+	Only allow this kind of editing:	僅允許此類編輯:
+	Only comments can be added, except in regions marked editable.	只能新增註解，標示為可編輯的區域除外。
+	Only form fields can be filled in.	只能填寫表單欄位。
+	Only the allowed styles can be applied.	只能套用允許的樣式。
+	Ordinals (1st) as superscript	序數 (1st) 取代為上標
+	Original document	原始文件
+	This password type isn't supported.	不支援此密碼類型。
+	Replace as you type	輸入時自動取代
+	Replace text as you type	輸入時自動取代文字
+	Replace:	取代:
+	Revised document	修訂的文件
+	Select text, then tick who can still edit it.	選取文字，然後勾選仍可編輯的人。
+	Settings…	設定…
+	Show changes at:	顯示變更的層級:
+	Show changes in:	顯示變更於:
+	Smart quotes instead of straight quotes	以彎引號取代直引號
+	Start Enforcing Protection	開始強制保護
+	Stop Protection	停止保護
+	Text boxes	文字方塊
+	The document is read only, except for regions marked editable.	文件為唯讀，標示為可編輯的區域除外。
+	The password is optional; without it anyone can stop the protection.	密碼為選用；沒有密碼，任何人都能停止保護。
+	This document	此文件
+	Tracked changes	追蹤修訂
+	Type the password to stop the protection.	輸入密碼以停止保護。
+	White space	空白
+	With:	取代為:
+	Word level	字組層級
 	In Line with Text	與文字同行
 	Square	矩形
 	Through	穿透
@@ -1397,6 +1527,36 @@
 	New Group	新增群組
 	Rename…	重新命名…
 	Ribbon and Quick Access Toolbar:	功能區和快速存取工具列：
+	Add Font…	新增字型…
+	Added Fonts	已新增的字型
+	Remove Added Font	移除已新增的字型
+	Recent Colors	最近使用的色彩
+	More Colors…	其他色彩…
+	Standard	標準
+	Current	目前
+	Colors:	色彩:
+	Color model:	色彩模式:
+	Red:	紅色:
+	Green:	綠色:
+	Blue:	藍色:
+	Hue:	色調:
+	Sat:	飽和度:
+	Lum:	亮度:
+	Hex:	十六進位:
+	Accessibility Pane	協助工具窗格
+	Alt Text Pane	替代文字窗格
+	Alt\nText	替代\n文字
+	View Alt Text…	檢視替代文字…
+	Mark as decorative	標示為裝飾用
+	Title:	標題：
+	Errors ({n})	錯誤 ({n})
+	Warnings ({n})	警告 ({n})
+	Tips ({n})	提示 ({n})
+	No accessibility issues found.	找不到協助工具問題。
+	Describe what this object shows, for people who can't see it.	請為看不見的人描述此物件顯示的內容。
+	Decorative objects only add visual interest: screen readers skip them.	裝飾用物件只增添視覺效果：螢幕助讀程式會略過它們。
+	Describe what this table shows, for people who can't see it.	請為看不見的人描述此表格顯示的內容。
+	Select a picture, shape, chart or table to describe it.	選取圖片、圖形、圖表或表格以加入描述。
 	Document Grid	文件格線
 	No grid	無格線
 	Lines only	僅行
@@ -1406,6 +1566,39 @@
 	Lines per page:	每頁行數：
 	Moved from	移動自
 	Moved to	移動到
+	Developer	開發人員
+	Controls	控制項
+	Rich Text Content Control	RTF 文字內容控制項
+	Plain Text Content Control	純文字內容控制項
+	Picture Content Control	圖片內容控制項
+	Building Block Gallery Content Control	建置組塊庫內容控制項
+	Check Box Content Control	核取方塊內容控制項
+	Combo Box Content Control	下拉式方塊內容控制項
+	Drop-Down List Content Control	下拉式清單內容控制項
+	Date Picker Content Control	日期選擇器內容控制項
+	Repeating Section Content Control	重複區段內容控制項
+	Design Mode	設計模式
+	Content Control at Selection	選取範圍的內容控制項
+	Toggle Check Box	切換核取方塊
+	Choose List Item	選擇清單項目
+	Set Date	設定日期
+	Remove Content Control	移除內容控制項
+	Content Control Properties	內容控制項屬性
+	Title	標題
+	Tag	標籤
+	Placeholder text	預留位置文字
+	Can't be deleted	無法刪除
+	Contents can't be edited	無法編輯內容
+	Remove the control once edited	編輯後移除控制項
+	Allow line breaks	允許換行
+	Date format	日期格式
+	Checked symbol	已勾選符號
+	Unchecked symbol	未勾選符號
+	List entries	清單項目
+	Display text	顯示文字
+	Value	值
+	Today	今天
+	Put the caret in a content control first.	請先將游標放在內容控制項中。
 	Right-to-Left Table	從右至左表格
 	Right-to-Left Section	從右至左節
 	Table direction:	表格方向：
@@ -1433,6 +1626,50 @@
 	Enlarge symbol	放大符號
 	Enclosure	圍繞符號
 	Circle	圓形
+	Templates	範本
+	Templates and Add-ins	範本與增益集
+	Attach Template	附加範本
+	Detach Template	中斷範本連結
+	Automatically Update Document Styles	自動更新文件樣式
+	Update Styles from Template	從範本更新樣式
+	Organizer	管理器
+	Copy Styles	複製樣式
+	Rename Style	重新命名樣式
+	Document template:	文件範本：
+	Attach…	附加…
+	Automatically update document styles	自動更新文件樣式
+	Organizer…	管理器…
+	Change Chart Type	變更圖表類型
+	Chart Design	圖表設計
+	Type	類型
+	Edit Data	編輯資料
+	Chart Title	圖表標題
+	Chart Layouts	圖表版面配置
+	Add Chart Element	新增圖表項目
+	Legend	圖例
+	Data Labels	資料標籤
+	Above Chart	圖表上方
+	Insert Chart	插入圖表
+	Clustered Column	群組直條圖
+	Stacked Column	堆疊直條圖
+	Clustered Bar	群組橫條圖
+	Stacked Bar	堆疊橫條圖
+	Area	區域圖
+	Pie	圓形圖
+	Doughnut	環圈圖
+	Scatter	散佈圖
+	“{text}” ({row}, {series}) isn't a number.	「{text}」（{row}，{series}）不是數字。
+	Category {n}	類別 {n}
+	Series {n}	數列 {n}
+	Type the categories down the side and a column of values per series.	在左側輸入類別，每個數列輸入一欄數值。
+	Categories	類別
+	Series name	數列名稱
+	Remove series	移除數列
+	Remove row	移除列
+	Add Row	新增列
+	Add Series	新增數列
+	Edit\nData	編輯\n資料
+	Change\nChart Type	變更\n圖表類型
 	Align Text	對齊文字
 	Create Link	建立連結
 	Break Link	中斷連結
@@ -1457,3 +1694,346 @@
 	English (United Kingdom)	英文（英國）
 	Polish	波蘭文
 	Do Not Check Spelling or Grammar	不檢查拼字及文法
+
+# Built-in file browser when the system file dialog is unavailable (#576)
+	Documents	文件
+	Word document	Word 文件
+	All files	所有檔案
+	Recipient lists	收件者清單
+	The system file dialog isn't available, so WordCraft shows its own. To get the system dialog, install a file chooser portal (such as xdg-desktop-portal-gtk) or zenity.	系統檔案對話方塊無法使用，因此 WordCraft 顯示自己的對話方塊。若要使用系統對話方塊，請安裝檔案選擇器入口（例如 xdg-desktop-portal-gtk）或 zenity。
+	Up one level	上移一層
+	Home folder	個人資料夾
+	{name} wasn't found.	找不到 {name}。
+	{name} already exists. Choose Save again to replace it.	{name} 已存在。再次選擇「儲存」即可取代它。
+	This folder can't be read: {error}	無法讀取此資料夾：{error}
+	Showing the first {count} items.	僅顯示前 {count} 個項目。
+	File name:	檔案名稱:
+	Browse in WordCraft…	在 WordCraft 中瀏覽…
+	Open a file with WordCraft's own browser when the system file dialog doesn't appear.	當系統檔案對話方塊沒有出現時，使用 WordCraft 內建的瀏覽器開啟檔案。
+	Hide White Space	隱藏空白
+	All pages	所有頁面
+	Current page	目前頁面
+	Selected pages	所選頁面
+	Custom range	自訂範圍
+	All pages in the range	範圍內的所有頁面
+	Odd pages only	僅奇數頁
+	Even pages only	僅偶數頁
+	Copies	份數
+	Collate copies	逐份列印
+	Pages like 1-3, 5	頁碼,如 1-3, 5
+	{count} of {total} pages will print	將列印 {total} 頁中的 {count} 頁
+	Save these pages as PDF…	將這些頁面另存為 PDF…
+	The printer, two-sided printing and pages per sheet are chosen in that dialog.	印表機、雙面列印和每張頁數在該對話方塊中選擇。
+	Previous Page	上一頁
+	Print to PDF	列印為 PDF
+	Add Shape	新增圖案
+	Change Colors	變更色彩
+	Change Layout	變更版面配置
+	Create Graphic	建立圖形
+	Edit Items	編輯項目
+	Layouts	版面配置
+	Reset Graphic	重設圖形
+	SmartArt Design	SmartArt 設計
+	SmartArt Styles	SmartArt 樣式
+	Text Pane	文字窗格
+	List	清單
+	Process	流程
+	Cycle	循環
+	Hierarchy	階層
+	Relationship	關聯
+	Pyramid	金字塔圖
+	Basic List	基本清單
+	Basic Process	基本流程
+	Basic Cycle	基本循環
+	Basic Pyramid	基本金字塔圖
+	Basic Radial	基本放射圖
+	Basic Matrix	基本矩陣
+	Basic Venn	基本文氏圖
+	Shows items of equal weight as blocks in rows.	將同等重要的項目顯示為成列排列的區塊。
+	Shows steps in order, left to right, with arrows between them.	依由左至右的順序顯示步驟，步驟之間以箭號連接。
+	Shows steps that repeat, around a circle.	沿圓周顯示重複的步驟。
+	Shows a tree: each item below the item it belongs to.	顯示樹狀結構：每個項目位於其所屬項目的下方。
+	Shows parts that build on each other, largest at the bottom.	顯示層層堆疊的部分，最大的在底部。
+	Shows items around a central idea: the first item is the centre.	圍繞中心概念顯示項目：第一個項目位於中心。
+	Shows parts of a whole as quadrants.	將整體的各部分顯示為象限。
+	Shows overlapping ideas as overlapping circles.	將相互重疊的概念顯示為重疊的圓形。
+	Accent {n}	輔色 {n}
+	Colorful	彩色
+	Insert SmartArt	插入 SmartArt
+	One line per item. Enter adds an item.	每個項目一行。按 Enter 新增項目。
+	Add\nShape	新增\n圖案
+	Change\nColors	變更\n色彩
+	Reset\nGraphic	重設\n圖形
+	Promote to Heading 1	升級至標題 1
+	Demote to Body Text	降級為本文
+	Move Up	上移
+	Move Down	下移
+	Collapse	摺疊
+	Expand or Collapse Heading	展開或摺疊標題
+	Select Heading and Content	選取標題及其內容
+	Show Level	顯示階層
+	Show Level 1	顯示第 1 階
+	Show Level 2	顯示第 2 階
+	Show Level 3	顯示第 3 階
+	Show Level 4	顯示第 4 階
+	Show Level 5	顯示第 5 階
+	Show Level 6	顯示第 6 階
+	Show Level 7	顯示第 7 階
+	Show Level 8	顯示第 8 階
+	Show Level 9	顯示第 9 階
+	Show All Levels	顯示所有階層
+	All Levels	所有階層
+	Show First Line Only	僅顯示首行
+	Show Text Formatting	顯示文字格式設定
+	Close Outline View	關閉大綱模式
+	Outline State	大綱狀態
+	Outlining	大綱
+	Outline Tools	大綱工具
+	Close Outline\nView	關閉\n大綱模式
+	A, B, C, …	A, B, C, …
+	Above the item	項目上方
+	Accessed on	存取日期
+	Add New Source…	新增來源…
+	Add the chapter number	加入章節編號
+	Atmosphere	大氣
+	Below the item	項目下方
+	Book	書籍
+	Book title	書名
+	Caption	標號
+	Caption Numbering	標號編號
+	Caption text	標號文字
+	Caption:	標號：
+	Chapter in a book	書籍章節
+	Chapters begin at:	章節起始於：
+	Collect entries from:	項目來源：
+	Columns:	欄數：
+	Conference	會議
+	Conference paper	會議論文
+	Container Title	載體標題
+	Create Source	建立來源
+	Cross-reference:	交互參照：
+	Custom Table of Contents…	自訂目錄…
+	DOI	DOI
+	Day	日
+	Delete Label	刪除標籤
+	Edit Source	編輯來源
+	Edition	版次
+	Edit…	編輯…
+	Entry marked.	已標記項目。
+	Example: {sample}	範例：{sample}
+	Figure	圖
+	Film	電影
+	Heading styles (levels 1–{n})	標題樣式（階層 1–{n}）
+	Heading {n}	標題 {n}
+	I, II, III, …	I, II, III, …
+	Include page numbers	包含頁碼
+	Indented	縮排式
+	Institution	機構
+	Ionosphere	電離層
+	Issue	期號
+	Journal	期刊
+	Label:	標籤：
+	Last, First; Last, First	姓, 名; 姓, 名
+	Leave the label out of the caption	標號中不含標籤
+	Letter headings	字母標題
+	Levels:	階層：
+	Link entries to their headings	將項目連結到標題
+	Made from the author and year when empty	留空時由作者和年份產生
+	Magazine or newspaper article	雜誌或報紙文章
+	Main entry:	主索引項：
+	Mark	標記
+	Mark All	全部標記
+	Mark Entry…	標記項目…
+	Mark Index Entry	標記索引項目
+	Mesosphere	中氣層
+	Month	月
+	New Label	新增標籤
+	New Label…	新增標籤…
+	New…	新增…
+	No sources yet.	尚無來源。
+	Numbering…	編號…
+	Options…	選項…
+	Other	其他
+	Other styles and their TOC level:	其他樣式及其目錄階層：
+	Outline levels	大綱階層
+	Page number style	頁碼樣式
+	Page numbers at the right margin	頁碼靠右邊界
+	Page title	頁面標題
+	Pages of bookmark:	書籤所在頁：
+	Periodical	期刊名
+	Position:	位置：
+	Publisher	出版者
+	Run-in	接排式
+	See	參見
+	Separator:	分隔符號：
+	Show every bibliography field	顯示所有書目欄位
+	Site name	網站名稱
+	Source Manager	來源管理員
+	Source type:	來源類型：
+	Sources in this document:	此文件中的來源：
+	Styles:	樣式：
+	Subentry:	次索引項：
+	TC entry fields	TC 項目功能變數
+	Tab leader:	定位點前置字元：
+	Table of Contents Options	目錄選項
+	Table of Contents Styles	目錄樣式
+	This page	目前頁面
+	Type:	類型：
+	URL	URL
+	Volume	卷
+	Website	網站
+	Year	年份
+	a, b, c, …	a, b, c, …
+	i, ii, iii, …	i, ii, iii, …
+	{n} entries marked.	已標記 {n} 個項目。
+	Lasso Select	套索選取
+	Move Selected Ink	移動選取的筆跡
+	Delete Selected Ink	刪除選取的筆跡
+	Recolor Selected Ink	變更選取筆跡的色彩
+	Add Pen	新增畫筆
+	Remove Pen	移除畫筆
+	Ink to Shape	筆跡轉圖形
+	Convert to Shapes	轉換為圖案
+	Ink Replay	筆跡重播
+	Add\nPen	新增畫筆
+	Rewind	倒轉
+	Forward	快轉
+	Stroke {n} of {total}	第 {n} 筆，共 {total} 筆
+	Use wildcards	使用萬用字元
+	Special	特殊字元
+	Match prefix	比對字首
+	Match suffix	比對字尾
+	Ignore punctuation characters	忽略標點符號
+	Ignore white-space characters	忽略空白字元
+	Regular expressions	規則運算式
+	Search Options	搜尋選項
+	Tab Character	定位字元符號
+	Any Character	任意字元
+	Any Digit	任意數字
+	Any Letter	任意字母
+	Caret Character	插入號
+	Section Character	章節符號
+	Paragraph Character	段落符號
+	Graphic	圖形
+	Manual Line Break	手動換行
+	Manual Page Break	手動分頁
+	Section Break	分節符號
+	White Space	空白
+	Clipboard Contents	剪貼簿內容
+	Find What Text	找到的文字
+	Find What Expression	找到的運算式
+	Character in Range	範圍內的字元
+	Beginning of Word	單字開頭
+	End of Word	單字結尾
+	Expression	運算式
+	Not	非
+	Num Occurrences	出現次數
+	Previous 1 or More	前一項 1 次以上
+	0 or More Characters	0 個以上字元
+	Move with Text	隨文字移動
+	Fix Position on Page	固定於頁面上的位置
+
+# WordArt and connectors (#416).
+	WordArt Styles	文字藝術師樣式
+	Text Fill	文字填滿
+	Text Outline	文字外框
+	Transform	轉換
+	No Fill	無填滿
+	No Outline	無外框
+	Reflection	反射
+	No Reflection	無反射
+	No Transform	無轉換
+	Connect Shapes	連接圖案
+	Straight Connector	直線接點
+	Straight Arrow Connector	直線箭頭接點
+	Elbow Connector	肘形接點
+	Elbow Arrow Connector	肘形箭頭接點
+	Curved Connector	曲線接點
+	Curved Arrow Connector	曲線箭頭接點
+	Arch Up	上彎弧形
+	Arch Down	下彎弧形
+	Slant Up	向上傾斜
+	Slant Down	向下傾斜
+	Inflate	膨脹
+	Deflate	收縮
+	Chevron Up	向上V形
+	Chevron Down	向下V形
+	Triangle Up	正三角形
+	Triangle Down	倒三角形
+	Solid Accent	實心強調色
+	Light with Outline	淺色加外框
+	Hollow	空心
+	Accent Gradient	強調色漸層
+	Dark with Shadow	深色加陰影
+	Soft Glow	柔和光暈
+	Accent with Reflection	強調色加反射
+	Warm Gradient with Outline	暖色漸層加外框
+	Add line numbering	新增行號
+	Add to Document	新增至文件
+	Address labels	地址標籤
+	Arabic	阿拉伯文
+	Auto	自動
+	Automatically hyphenate document	自動斷字
+	Chinese (Simplified)	中文（簡體）
+	Chinese (Traditional)	中文（繁體）
+	Column:	欄：
+	Count by:	行號間距：
+	Czech	捷克文
+	Danish	丹麥文
+	Delivery address:	收件人地址：
+	Detect language automatically	自動偵測語言
+	Do not check spelling or grammar	不要檢查拼字或文法
+	Dutch	荷蘭文
+	Envelope size:	信封大小：
+	Estonian	愛沙尼亞文
+	Finnish	芬蘭文
+	French (France)	法文（法國）
+	From text:	距本文：
+	Full page of the same label	整頁相同的標籤
+	German (Germany)	德文（德國）
+	Greek	希臘文
+	Hebrew	希伯來文
+	Hyphenate at:	斷字位置：
+	Hyphenate words in CAPS	大寫單字斷字
+	Hyphenation Options…	斷字選項…
+	Hyphenation zone:	斷字區：
+	Italian	義大利文
+	Japanese	日文
+	Korean	韓文
+	Limit consecutive hyphens to:	連續斷字數上限：
+	Line Numbering Options…	行號選項…
+	Manual Hyphenation	手動斷字
+	Manual hyphenation is complete.	手動斷字已完成。
+	Manual…	手動…
+	Mark selected text as:	將選取的文字標示為：
+	New Document	新文件
+	No limit	不限
+	Norwegian (Bokmål)	挪威文（巴克摩）
+	Numbering:	編號：
+	Omit	省略
+	One label per recipient	每位收件人一個標籤
+	Portuguese (Brazil)	葡萄牙文（巴西）
+	Portuguese (Portugal)	葡萄牙文（葡萄牙）
+	Return address labels	寄件人地址標籤
+	Return address:	寄件人地址：
+	Row:	列：
+	Russian	俄文
+	Serbian (Cyrillic)	塞爾維亞文（斯拉夫文）
+	Serbian (Latin)	塞爾維亞文（拉丁文）
+	Set As Default	設為預設值
+	Shipping labels	寄送標籤
+	Single label	單一標籤
+	Spanish (Mexico)	西班牙文（墨西哥）
+	Spanish (Spain)	西班牙文（西班牙）
+	Swedish	瑞典文
+	Turkish	土耳其文
+	Ukrainian	烏克蘭文
+	{language} is now the document's default language.	{language} 現在是此文件的預設語言。
+	Visual effects	視覺效果
+	Animation effects:	動畫效果：
+	On	開
+	Off	關
+	Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.	平滑捲動與縮放，以及功能表與按鈕的淡入效果。選擇「關」後，所有變更會立即顯示。
+	Your system has animation effects turned on.	系統已開啟動畫效果。
+	Your system has animation effects turned off.	系統已關閉動畫效果。
+	Your system doesn't report an animation setting, so animation effects stay on.	系統未提供動畫設定，因此動畫效果保持開啟。
diff --git a/crates/ui-egui/src/icons.rs b/crates/ui-egui/src/icons.rs
index c8fa350dc7..87ae0ebd22 100644
--- a/crates/ui-egui/src/icons.rs
+++ b/crates/ui-egui/src/icons.rs
@@ -354,12 +354,83 @@ pub fn paint(p: &Painter, r: Rect, name: &str, c: Color32, accent: Color32) {
             pen.line(&[(10.0, 6.5), (10.0, 10.0), (5.0, 10.0), (5.0, 13.0)]);
             pen.line(&[(10.0, 10.0), (15.0, 10.0), (15.0, 13.0)]);
         }
+        "addShape" => {
+            pen.frect(2.5, 3.0, 9.5, 8.0, a);
+            pen.rect(2.5, 12.0, 9.5, 17.0, c);
+            pen.line(&[(6.0, 8.0), (6.0, 12.0)]);
+            pen.line_c(&[(14.5, 10.5), (14.5, 17.5)], green);
+            pen.line_c(&[(11.0, 14.0), (18.0, 14.0)], green);
+        }
+        "promote" => {
+            pen.lines(9.0, 17.5, &[5.0, 10.0, 15.0]);
+            pen.line_c(&[(6.5, 7.5), (3.0, 10.0), (6.5, 12.5)], a);
+        }
+        "demote" => {
+            pen.lines(9.0, 17.5, &[5.0, 10.0, 15.0]);
+            pen.line_c(&[(3.0, 7.5), (6.5, 10.0), (3.0, 12.5)], a);
+        }
+        "textPane" => {
+            pen.rect(2.5, 3.0, 17.5, 17.0, c);
+            pen.line(&[(9.0, 3.0), (9.0, 17.0)]);
+            pen.lines(4.0, 7.5, &[6.5, 10.0, 13.5]);
+            pen.frect(11.0, 6.0, 16.0, 9.0, a);
+            pen.frect(11.0, 11.5, 16.0, 14.5, a);
+        }
+        "smartArtColors" => {
+            pen.fcircle(7.0, 7.5, 4.0, a);
+            pen.fcircle(13.0, 7.5, 4.0, orange);
+            pen.fcircle(10.0, 13.0, 4.0, green);
+            pen.circle(10.0, 10.0, 8.0, c);
+        }
+        "resetGraphic" => {
+            pen.rect(7.5, 6.5, 16.5, 15.5, c);
+            pen.frect(9.5, 8.5, 14.5, 13.5, a);
+            pen.line(&[(3.5, 13.0), (3.5, 4.0), (11.0, 4.0)]);
+            pen.line(&[(1.5, 6.0), (3.5, 4.0), (5.5, 6.0)]);
+        }
         "chart" => {
             pen.frect(3.5, 11.0, 6.5, 17.0, a);
             pen.frect(8.5, 6.0, 11.5, 17.0, orange);
             pen.frect(13.5, 9.0, 16.5, 17.0, green);
             pen.line(&[(2.0, 17.5), (18.0, 17.5)]);
         }
+        "changeChartType" => {
+            pen.frect(3.0, 11.0, 5.5, 17.0, a);
+            pen.frect(7.0, 7.0, 9.5, 17.0, orange);
+            pen.line(&[(2.0, 17.5), (11.0, 17.5)]);
+            pen.fill(&[(15.0, 10.0), (15.0, 5.0), (19.0, 8.5)], green);
+            pen.circle(15.0, 10.0, 4.0, c);
+            pen.line_c(&[(4.0, 5.0), (9.0, 2.5), (12.0, 4.5)], a);
+        }
+        "chartData" => {
+            pen.rect(2.5, 3.0, 17.5, 17.0, c);
+            pen.frect(2.5, 3.0, 17.5, 6.5, a);
+            pen.line(&[(2.5, 10.0), (17.5, 10.0)]);
+            pen.line(&[(2.5, 13.5), (17.5, 13.5)]);
+            pen.line(&[(7.5, 3.0), (7.5, 17.0)]);
+            pen.line(&[(12.5, 3.0), (12.5, 17.0)]);
+            pen.frect(9.0, 14.5, 11.0, 16.0, orange);
+        }
+        "chartTitle" => {
+            pen.frect(5.0, 2.5, 15.0, 4.5, a);
+            pen.frect(4.0, 11.0, 7.0, 17.0, c);
+            pen.frect(8.5, 8.0, 11.5, 17.0, c);
+            pen.frect(13.0, 12.5, 16.0, 17.0, c);
+            pen.line(&[(2.5, 17.5), (17.5, 17.5)]);
+        }
+        "legend" => {
+            for (k, col) in [a, orange, green].into_iter().enumerate() {
+                let y = 5.0 + 5.0 * k as f32;
+                pen.frect(3.0, y - 1.5, 6.0, y + 1.5, col);
+                pen.line(&[(8.0, y), (17.0, y)]);
+            }
+        }
+        "dataLabels" => {
+            pen.frect(3.5, 11.0, 7.0, 17.5, a);
+            pen.frect(12.0, 8.0, 15.5, 17.5, orange);
+            pen.rect(2.5, 5.5, 8.0, 9.0, c);
+            pen.rect(11.0, 2.5, 16.5, 6.0, c);
+        }
         "screenshot" => {
             pen.line(&[(3.0, 7.0), (3.0, 3.0), (7.0, 3.0)]);
             pen.line(&[(13.0, 3.0), (17.0, 3.0), (17.0, 7.0)]);
@@ -439,6 +510,26 @@ pub fn paint(p: &Painter, r: Rect, name: &str, c: Color32, accent: Color32) {
             pen.text(10.0, 10.5, 15.0, "A", a, true);
             pen.line_c(&[(3.0, 17.5), (17.0, 17.5)], orange);
         }
+        "textFill" => {
+            pen.text(10.0, 8.5, 13.0, "A", c, true);
+            pen.frect(3.0, 15.0, 17.0, 18.5, a);
+        }
+        "textOutline" => {
+            pen.text(10.0, 8.5, 13.0, "A", a, false);
+            pen.rect(3.0, 15.0, 17.0, 18.5, c);
+        }
+        "transform" => {
+            // Letters along an arch.
+            let arc: Vec<(f32, f32)> = (0..=12)
+                .map(|i| {
+                    let t = std::f32::consts::PI * (1.0 - i as f32 / 12.0);
+                    (10.0 + 7.5 * t.cos(), 15.0 - 9.0 * t.sin())
+                })
+                .collect();
+            pen.line_c(&arc, a);
+            pen.text(10.0, 13.0, 8.0, "A", c, true);
+            pen.line(&[(2.5, 17.5), (17.5, 17.5)]);
+        }
         "dropCap" => {
             pen.text(6.0, 8.0, 12.0, "A", a, true);
             pen.lines(11.0, 17.0, &[4.0, 8.0, 12.0]);
@@ -498,6 +589,27 @@ pub fn paint(p: &Painter, r: Rect, name: &str, c: Color32, accent: Color32) {
             pen.circle(10.0, 10.0, 6.5, c);
             pen.fill(&[(8.5, 7.0), (8.5, 13.0), (13.0, 10.0)], a);
         }
+        // Add Pen: a pen with a plus.
+        "addPen" => {
+            pen.line(&[(3.0, 17.0), (11.0, 9.0), (13.0, 11.0), (5.0, 19.0), (2.5, 19.5), (3.0, 17.0)]);
+            pen.fill(&[(11.0, 9.0), (12.5, 7.5), (14.5, 9.5), (13.0, 11.0)], a);
+            pen.line_c(&[(15.0, 2.0), (15.0, 8.0)], a);
+            pen.line_c(&[(12.0, 5.0), (18.0, 5.0)], a);
+        }
+        // Ink Replay's controls.
+        "replayRewind" => {
+            pen.frect(4.0, 5.0, 5.5, 15.0, c);
+            pen.fill(&[(16.0, 5.0), (16.0, 15.0), (6.5, 10.0)], c);
+        }
+        "replayPlay" => pen.fill(&[(6.0, 4.0), (6.0, 16.0), (16.0, 10.0)], a),
+        "replayPause" => {
+            pen.frect(5.5, 4.5, 8.5, 15.5, a);
+            pen.frect(11.5, 4.5, 14.5, 15.5, a);
+        }
+        "replayForward" => {
+            pen.fill(&[(4.0, 5.0), (4.0, 15.0), (13.5, 10.0)], c);
+            pen.frect(14.5, 5.0, 16.0, 15.0, c);
+        }
         // Design
         "themes" => {
             pen.frect(3.0, 3.0, 10.0, 10.0, a);
@@ -761,6 +873,14 @@ pub fn paint(p: &Painter, r: Rect, name: &str, c: Color32, accent: Color32) {
             pen.line(&[(10.0, 7.0), (10.0, 12.0), (7.0, 17.5)]);
             pen.line(&[(10.0, 12.0), (13.0, 17.5)]);
         }
+        "altText" => {
+            // A small picture with lines of text beside and below it.
+            pen.rect(2.5, 3.5, 11.5, 11.0, c);
+            pen.line_c(&[(3.5, 10.0), (6.0, 6.5), (8.0, 8.5), (9.0, 7.5), (10.5, 10.0)], a);
+            for (x0, x1, y) in [(13.5, 17.5, 5.0), (13.5, 17.5, 8.0), (2.5, 17.5, 14.0), (2.5, 13.0, 17.0)] {
+                pen.line_c(&[(x0, y), (x1, y)], c);
+            }
+        }
         "translate" | "language" => {
             pen.text(6.5, 7.0, 9.0, "A", c, true);
             pen.text(13.5, 13.5, 9.0, "あ", a, false);
@@ -938,6 +1058,12 @@ pub fn paint(p: &Painter, r: Rect, name: &str, c: Color32, accent: Color32) {
             pen.rect(3.0, 3.0, 17.0, 17.0, c);
             pen.fill(&[(8.0, 6.5), (8.0, 13.5), (14.0, 10.0)], a);
         }
+        // A page with a filled band at the top and a style mark: the document's template.
+        "documentTemplate" => {
+            pen.page(4.0, 2.0, 16.0, 18.0);
+            pen.frect(6.0, 5.0, 11.5, 7.0, a);
+            pen.text(10.0, 13.0, 8.0, "A", a, false);
+        }
         "properties" | "info" => {
             pen.circle(10.0, 10.0, 7.0, c);
             pen.line_c(&[(10.0, 9.0), (10.0, 14.5)], a);
@@ -1071,7 +1197,9 @@ pub fn paint(p: &Painter, r: Rect, name: &str, c: Color32, accent: Color32) {
             pen.line(&[(5.0, 5.0), (15.0, 15.0)]);
             pen.line(&[(15.0, 5.0), (5.0, 15.0)]);
         }
-        "dropdown" => pen.arrow_down(10.0, 10.0, c),
+        // A triangle filling most of its box: it is drawn at 9–12 pt beside combos and split
+        // buttons, where a smaller one shrank to a dot (#535).
+        "dropdown" => pen.fill(&[(3.0, 7.0), (17.0, 7.0), (10.0, 14.0)], c),
         "more" => {
             for x in [5.0, 10.0, 15.0] {
                 pen.fcircle(x, 10.0, 1.3, c);
@@ -1169,10 +1297,124 @@ pub fn paint(p: &Painter, r: Rect, name: &str, c: Color32, accent: Color32) {
                 pen.line_c(&[(6.5, 16.5), (9.0, 11.5)], c);
             }
         }
+
+        // The built-in file browser (#576): a folder, a file and the home folder.
+        "folder" => {
+            pen.frect(2.5, 4.5, 8.5, 7.0, yellow);
+            pen.frect(2.5, 6.5, 17.5, 16.0, yellow);
+            pen.closed(&[(2.5, 4.5), (8.0, 4.5), (9.5, 6.5), (17.5, 6.5), (17.5, 16.0), (2.5, 16.0)], c);
+        }
+        "file" => {
+            pen.page(4.5, 2.0, 15.5, 18.0);
+            pen.lines(7.0, 13.0, &[9.0, 12.0, 15.0]);
+        }
+        "homeFolder" => {
+            pen.closed(&[(3.0, 9.5), (10.0, 3.5), (17.0, 9.5)], c);
+            pen.closed(&[(5.0, 8.5), (5.0, 17.0), (15.0, 17.0), (15.0, 8.5)], c);
+            pen.frect(8.5, 12.0, 11.5, 17.0, a);
+        }
+
+        // Outlining tab: arrows moving a paragraph between outline levels and along the outline.
+        "outlinePromote" | "outlineDemote" => {
+            pen.lines(9.0, 17.0, &[6.0, 10.0, 14.0]);
+            if name == "outlinePromote" {
+                pen.line_c(&[(7.0, 10.0), (2.5, 10.0)], a);
+                pen.line_c(&[(5.0, 7.5), (2.5, 10.0), (5.0, 12.5)], a);
+            } else {
+                pen.line_c(&[(2.5, 10.0), (7.0, 10.0)], a);
+                pen.line_c(&[(4.5, 7.5), (7.0, 10.0), (4.5, 12.5)], a);
+            }
+        }
+        "outlineTop" | "outlineBody" => {
+            pen.lines(11.0, 17.0, &[6.0, 10.0, 14.0]);
+            let (x, d) = if name == "outlineTop" { (3.0, 1.0) } else { (9.0, -1.0) };
+            for k in [0.0, 3.5] {
+                pen.line_c(&[(x + d * k + d * 2.5, 7.0), (x + d * k, 10.0), (x + d * k + d * 2.5, 13.0)], a);
+            }
+        }
+        "outlineUp" | "outlineDown" => {
+            pen.lines(3.0, 11.0, &[6.0, 10.0, 14.0]);
+            let up = name == "outlineUp";
+            let (tip, tail) = if up { (3.0, 17.0) } else { (17.0, 3.0) };
+            pen.line_c(&[(15.0, tail), (15.0, tip)], a);
+            let wing = if up { tip + 3.0 } else { tip - 3.0 };
+            pen.line_c(&[(12.0, wing), (15.0, tip), (18.0, wing)], a);
+        }
+        "outlineExpand" | "outlineCollapse" => {
+            pen.fcircle(10.0, 10.0, 6.5, c);
+            pen.line_c(&[(6.5, 10.0), (13.5, 10.0)], Color32::WHITE);
+            if name == "outlineExpand" {
+                pen.line_c(&[(10.0, 6.5), (10.0, 13.5)], Color32::WHITE);
+            }
+        }
+        "closeOutline" => {
+            pen.page(4.0, 2.0, 16.0, 18.0);
+            pen.line_c(&[(7.0, 8.0), (13.0, 14.0)], red);
+            pen.line_c(&[(13.0, 8.0), (7.0, 14.0)], red);
+        }
         "help" => {
             pen.circle(10.0, 10.0, 7.0, c);
             pen.text(10.0, 10.0, 10.0, "?", a, true);
         }
+        // Developer › Controls: a field's frame with what it holds.
+        "ccRichText" => {
+            pen.rect(2.5, 5.0, 17.5, 15.0, a);
+            pen.text(7.5, 10.0, 8.0, "A", c, true);
+            pen.text(13.0, 10.5, 7.0, "a", c, false);
+        }
+        "ccPlainText" => {
+            pen.rect(2.5, 5.0, 17.5, 15.0, a);
+            pen.text(8.0, 10.0, 8.0, "A", c, false);
+            pen.line(&[(12.0, 7.5), (12.0, 12.5)]);
+        }
+        "ccPicture" => {
+            pen.rect(2.5, 4.0, 17.5, 16.0, a);
+            pen.line(&[(4.5, 14.0), (8.5, 9.5), (11.5, 12.5), (13.5, 10.5), (15.5, 14.0)]);
+            pen.fcircle(13.5, 7.0, 1.2, c);
+        }
+        "ccGallery" => {
+            pen.rect(2.5, 3.0, 17.5, 17.0, a);
+            pen.frect(5.0, 5.5, 9.0, 9.5, c);
+            pen.frect(11.0, 5.5, 15.0, 9.5, c);
+            pen.lines(5.0, 15.0, &[12.5, 15.0]);
+        }
+        "ccCheckBox" => {
+            pen.rect(4.0, 4.0, 16.0, 16.0, c);
+            pen.line_c(&[(6.5, 10.0), (9.0, 13.0), (14.0, 6.5)], a);
+        }
+        "ccComboBox" => {
+            pen.rect(2.5, 6.0, 17.5, 14.0, c);
+            pen.line(&[(13.0, 6.0), (13.0, 14.0)]);
+            pen.lines(4.5, 10.5, &[10.0]);
+            pen.arrow_down(15.25, 10.0, a);
+        }
+        "ccDropDown" => {
+            pen.rect(2.5, 3.0, 17.5, 9.0, c);
+            pen.line(&[(13.0, 3.0), (13.0, 9.0)]);
+            pen.arrow_down(15.25, 6.0, a);
+            pen.rect(2.5, 9.0, 13.0, 17.0, c);
+            pen.lines(4.5, 11.0, &[11.5, 14.5]);
+        }
+        "ccDate" => {
+            pen.rect(3.0, 4.5, 17.0, 17.0, c);
+            pen.frect(3.0, 4.5, 17.0, 8.0, a);
+            pen.line(&[(6.5, 3.0), (6.5, 6.0)]);
+            pen.line(&[(13.5, 3.0), (13.5, 6.0)]);
+            for (x, y) in [(6.5, 11.0), (10.0, 11.0), (13.5, 11.0), (6.5, 14.5), (10.0, 14.5)] {
+                pen.fcircle(x, y, 0.9, c);
+            }
+        }
+        "ccRepeat" => {
+            pen.rect(2.5, 3.0, 17.5, 17.0, a);
+            pen.rect(5.0, 5.5, 15.0, 9.5, c);
+            pen.rect(5.0, 11.0, 15.0, 15.0, c);
+            pen.line_c(&[(10.0, 15.0), (10.0, 18.5)], a);
+        }
+        "designMode" => {
+            pen.line(&[(4.0, 16.0), (16.0, 16.0), (4.0, 4.0), (4.0, 16.0)]);
+            pen.line_c(&[(4.0, 12.0), (8.0, 16.0)], a);
+            pen.line(&[(7.0, 13.0), (7.0, 12.0)]);
+        }
         _ => {
             // Fallback: a rounded tile with the first letter.
             p.rect_stroke(r.shrink(r.width() * 0.12), 3.0, Stroke::new(1.0, c), egui::StrokeKind::Middle);
diff --git a/crates/ui-egui/src/ink.rs b/crates/ui-egui/src/ink.rs
index d3ca7c6ef0..2eebb6bf74 100644
--- a/crates/ui-egui/src/ink.rs
+++ b/crates/ui-egui/src/ink.rs
@@ -1,9 +1,14 @@
-//! Drawing on the page with the Draw tab's pens and eraser. While a pen is in use, a drag draws a
-//! live stroke and its release commits it with `draw.stroke` (one command, one undo step); with
-//! the eraser, a click or drag over a stroke deletes it with `draw.erase` (one undo step per
-//! drag). Select (or Esc) goes back to ordinary selection.
+//! Drawing on the page with the Draw tab's pens, eraser and lasso, and Ink Replay. While a pen
+//! is in use, a drag draws a live stroke and its release commits it with `draw.stroke` (one
+//! command, one undo step); with the eraser, a click or drag over a stroke deletes it with
+//! `draw.erase` (one undo step per drag). With the lasso, a drag draws a loop whose release
+//! selects the ink inside (`draw.lasso`); dragging the selection moves it (`draw.lassoMove`),
+//! Delete deletes it and Esc lets it go. Select (or Esc) goes back to ordinary selection.
+//!
+//! Ink Replay (`draw.replay`) hides the ink on the pages and draws the strokes again here, one
+//! after another in the order they were drawn, with a bar of controls at the bottom.
 
-use egui::{Color32, Painter, Pos2, Rect, Stroke, Ui};
+use egui::{Align2, Color32, Key, Painter, Pos2, Rect, Stroke, Ui, pos2, vec2};
 use serde_json::json;
 use wordcraft_doc::freeform::{InkTool, MAX_POINTS};
 use wordcraft_engine::cmd::draw::DrawMode;
@@ -19,13 +24,55 @@ pub struct InkDrag {
     pts: Vec<[f32; 2]>,
 }
 
+/// The lasso in use: a loop being drawn, or the selection being dragged (page points).
+pub enum LassoDrag {
+    Loop { page: usize, pts: Vec<[f32; 2]> },
+    Move { page: usize, from: [f32; 2], to: [f32; 2] },
+}
+
+/// Ink Replay in progress: the strokes in drawing order and how far it has got.
+pub struct Replay {
+    strokes: Vec<ReplayStroke>,
+    /// Seconds into the replay.
+    t: f32,
+    playing: bool,
+}
+
+struct ReplayStroke {
+    page: usize,
+    paths: Vec<Vec<[f32; 2]>>,
+    color: Color32,
+    width: f32,
+    /// When it starts being drawn and how long it takes, seconds.
+    start: f32,
+    dur: f32,
+}
+
+/// The Draw tab's pointer state beyond the pens (kept on the canvas).
+#[derive(Default)]
+pub struct InkUi {
+    pub(crate) lasso: Option<LassoDrag>,
+    pub(crate) replay: Option<Replay>,
+}
+
 /// Smallest move that adds a point to a live stroke, screen points.
 const MIN_STEP_PX: f32 = 1.5;
+/// How fast replayed ink is drawn, page points per second, and the pause between strokes.
+const REPLAY_SPEED: f32 = 400.0;
+const REPLAY_GAP: f32 = 0.12;
+/// How close to the lasso selection's frame a press still grabs it, page points.
+const GRAB_SLOP: f32 = 4.0;
 
-/// Handle the pointer while a pen or the eraser is in use; `true` when it did (no text
-/// selection or object dragging then).
+/// Handle the pointer while a pen, the eraser or the lasso is in use; `true` when it did (no
+/// text selection or object dragging then).
 pub fn pointer(app: &mut WordApp, ui: &Ui, resp: &egui::Response, rects: &[Rect], layout: &DocLayout, scale: f32) -> bool {
     let mode = app.session.view.draw.mode;
+    if mode != DrawMode::Lasso {
+        app.canvas.ink_ui.lasso = None;
+        if app.session.view.draw.lasso.is_some() {
+            let _ = app.run("draw.lasso", json!({"clear": true}));
+        }
+    }
     if mode == DrawMode::Select {
         app.canvas.ink = None;
         app.canvas.erasing = None;
@@ -73,27 +120,120 @@ pub fn pointer(app: &mut WordApp, ui: &Ui, resp: &egui::Response, rects: &[Rect]
                 app.canvas.erasing = None;
             }
         }
+        DrawMode::Lasso => lasso_pointer(app, (starts, down, released, at), rects, layout, scale),
         DrawMode::Select => {}
     }
     true
 }
 
+fn lasso_pointer(app: &mut WordApp, (starts, down, released, at): (bool, bool, bool, Option<Pos2>), rects: &[Rect], layout: &DocLayout, scale: f32) {
+    if starts && let Some((page, x, y)) = at.and_then(|p| page_at(rects, layout, scale, p)) {
+        // A press on the selection drags it; anywhere else starts a new loop.
+        let grab = wordcraft_engine::cmd::draw::lasso_bounds(&app.session, layout).is_some_and(|(bp, r)| {
+            bp == page && x >= r.x - GRAB_SLOP && x <= r.right() + GRAB_SLOP && y >= r.y - GRAB_SLOP && y <= r.bottom() + GRAB_SLOP
+        });
+        app.canvas.ink_ui.lasso =
+            Some(if grab { LassoDrag::Move { page, from: [x, y], to: [x, y] } } else { LassoDrag::Loop { page, pts: vec![[x, y]] } });
+    } else if down
+        && let Some(p) = at
+        && let Some(d) = app.canvas.ink_ui.lasso.as_mut()
+    {
+        match d {
+            LassoDrag::Loop { page, pts } => {
+                if let Some((x, y)) = on_page(rects, layout, scale, *page, p) {
+                    let far = pts.last().is_none_or(|[lx, ly]| ((x - lx).powi(2) + (y - ly).powi(2)).sqrt() * scale >= MIN_STEP_PX * 2.0);
+                    if far && pts.len() < MAX_POINTS {
+                        pts.push([x, y]);
+                    }
+                }
+            }
+            LassoDrag::Move { page, to, .. } => {
+                if let Some((x, y)) = on_page(rects, layout, scale, *page, p) {
+                    *to = [x, y];
+                }
+            }
+        }
+    }
+    if released && let Some(d) = app.canvas.ink_ui.lasso.take() {
+        match d {
+            LassoDrag::Loop { page, pts } if pts.len() >= 3 => {
+                let _ = app.run("draw.lasso", json!({"page": page, "points": pts}));
+            }
+            // A click without a loop lets the selection go.
+            LassoDrag::Loop { .. } => {
+                let _ = app.run("draw.lasso", json!({"clear": true}));
+            }
+            LassoDrag::Move { from, to, .. } => {
+                let (dx, dy) = (to[0] - from[0], to[1] - from[1]);
+                if dx.abs() + dy.abs() > 0.25 {
+                    let _ = app.run("draw.lassoMove", json!({"dx": dx, "dy": dy}));
+                }
+            }
+        }
+    }
+}
+
+/// Keys the lasso and Ink Replay take: Delete deletes the lasso selection, Esc lets it go or
+/// stops the replay. `true` when the key was used.
+pub fn key(app: &mut WordApp, key: Key) -> bool {
+    if key == Key::Escape && app.session.view.draw.replay {
+        stop_replay(app);
+        return true;
+    }
+    let selected = wordcraft_engine::cmd::draw::lasso_selection(&app.session).is_some();
+    match key {
+        Key::Delete | Key::Backspace if selected => {
+            let _ = app.run("draw.lassoDelete", json!({}));
+            true
+        }
+        Key::Escape if selected => {
+            let _ = app.run("draw.lasso", json!({"clear": true}));
+            true
+        }
+        _ => false,
+    }
+}
+
 /// Page point under screen point `p` on `page` (outside the page too, clamped by the command).
 fn on_page(rects: &[Rect], layout: &DocLayout, scale: f32, page: usize, p: Pos2) -> Option<(f32, f32)> {
     let r = rects.get(page)?;
-    let s = layout.pages.get(page).map_or(scale, |pg| crate::canvas::page_screen_scale(*r, pg, scale));
-    (s > 0.0).then(|| ((p.x - r.min.x) / s, (p.y - r.min.y) / s))
+    let s = page_scale(rects, layout, scale, page)?;
+    Some(((p.x - r.min.x) / s, (p.y - r.min.y) / s))
 }
 
-/// The live stroke, drawn over the page until it is committed.
+/// Screen points per page point on `page`.
+fn page_scale(rects: &[Rect], layout: &DocLayout, scale: f32, page: usize) -> Option<f32> {
+    let r = rects.get(page)?;
+    let s = layout.pages.get(page).map_or(scale, |pg| crate::canvas::page_screen_scale(*r, pg, scale));
+    (s > 0.0).then_some(s)
+}
+
+/// Page points to screen points on `page`.
+fn to_screen(rects: &[Rect], layout: &DocLayout, scale: f32, page: usize) -> Option<impl Fn([f32; 2]) -> Pos2> {
+    let r = *rects.get(page)?;
+    let s = page_scale(rects, layout, scale, page)?;
+    Some(move |[x, y]: [f32; 2]| pos2(r.min.x + x * s, r.min.y + y * s))
+}
+
+/// The on-screen colour of ink: on a dark page (View > Switch Modes) it is mapped like every other
+/// document colour, so a stroke looks the same while it is drawn as after it is saved.
+fn screen_ink(dark: bool, c: wordcraft_doc::Rgb, alpha: u8) -> Color32 {
+    let opts = wordcraft_render::RenderOptions { dark, ..Default::default() };
+    let wordcraft_doc::Rgb(r, g, b) = opts.ink(c);
+    Color32::from_rgba_unmultiplied(r, g, b, alpha)
+}
+
+/// The live stroke, the lasso and its selection, and the replayed ink, drawn over the pages.
 pub fn paint(app: &WordApp, painter: &Painter, rects: &[Rect], layout: &DocLayout, scale: f32) {
+    paint_replay(app, painter, rects, layout, scale);
+    paint_lasso(app, painter, rects, layout, scale);
     let Some(d) = &app.canvas.ink else { return };
-    let Some(r) = rects.get(d.page) else { return };
-    let s = layout.pages.get(d.page).map_or(scale, |pg| crate::canvas::page_screen_scale(*r, pg, scale));
+    let Some(map) = to_screen(rects, layout, scale, d.page) else { return };
+    let s = page_scale(rects, layout, scale, d.page).unwrap_or(scale);
     let set = app.session.view.draw.settings(d.tool);
     let alpha = (d.tool.alpha() * 255.0).round() as u8;
-    let color = Color32::from_rgba_unmultiplied(set.color.0, set.color.1, set.color.2, alpha);
-    let pts: Vec<Pos2> = d.pts.iter().map(|[x, y]| egui::pos2(r.min.x + x * s, r.min.y + y * s)).collect();
+    let color = screen_ink(app.session.view.dark_mode, set.color, alpha);
+    let pts: Vec<Pos2> = d.pts.iter().map(|p| map(*p)).collect();
     let width = (set.width * s).max(1.0);
     if let [only] = pts.as_slice() {
         painter.circle_filled(*only, width / 2.0, color);
@@ -102,10 +242,213 @@ pub fn paint(app: &WordApp, painter: &Painter, rects: &[Rect], layout: &DocLayou
     }
 }
 
-/// The pointer over the page while a pen or the eraser is in use.
+fn paint_lasso(app: &WordApp, painter: &Painter, rects: &[Rect], layout: &DocLayout, scale: f32) {
+    let t = crate::theme::Tokens::get(painter.ctx());
+    let dash = |pts: &[Pos2]| egui::Shape::dashed_line(pts, Stroke::new(1.0, t.accent), 4.0, 3.0);
+    if let Some(LassoDrag::Loop { page, pts }) = &app.canvas.ink_ui.lasso
+        && let Some(map) = to_screen(rects, layout, scale, *page)
+    {
+        let mut loop_pts: Vec<Pos2> = pts.iter().map(|p| map(*p)).collect();
+        if let Some(first) = loop_pts.first().copied() {
+            loop_pts.push(first);
+        }
+        painter.extend(dash(&loop_pts));
+    }
+    let Some((page, r)) = wordcraft_engine::cmd::draw::lasso_bounds(&app.session, layout) else { return };
+    let (dx, dy) = match &app.canvas.ink_ui.lasso {
+        Some(LassoDrag::Move { from, to, .. }) => (to[0] - from[0], to[1] - from[1]),
+        _ => (0.0, 0.0),
+    };
+    let Some(map) = to_screen(rects, layout, scale, page) else { return };
+    let (a, b) = (map([r.x + dx, r.y + dy]), map([r.right() + dx, r.bottom() + dy]));
+    let sr = Rect::from_min_max(a, b).expand(3.0);
+    painter.extend(dash(&[sr.left_top(), sr.right_top(), sr.right_bottom(), sr.left_bottom(), sr.left_top()]));
+}
+
+/// The pointer over the page while a pen, the eraser or the lasso is in use.
 pub fn cursor(app: &WordApp) -> Option<egui::CursorIcon> {
     match app.session.view.draw.mode {
         DrawMode::Select => None,
-        DrawMode::Eraser | DrawMode::Pen(_) => Some(egui::CursorIcon::Crosshair),
+        DrawMode::Lasso if matches!(app.canvas.ink_ui.lasso, Some(LassoDrag::Move { .. })) => Some(egui::CursorIcon::Grabbing),
+        DrawMode::Eraser | DrawMode::Pen(_) | DrawMode::Lasso => Some(egui::CursorIcon::Crosshair),
+    }
+}
+
+// --- Ink Replay ----------------------------------------------------------------------------
+
+/// Start, advance or end Ink Replay with the session's `draw.replay` switch; call once a frame
+/// before the pages are drawn.
+pub fn replay_tick(app: &mut WordApp, ctx: &egui::Context) {
+    if !app.session.view.draw.replay {
+        app.canvas.ink_ui.replay = None;
+        return;
+    }
+    if app.canvas.ink_ui.replay.is_none() {
+        let mut start = 0.0;
+        let strokes: Vec<ReplayStroke> = wordcraft_engine::cmd::draw::strokes_in_drawing_order(&mut app.session)
+            .into_iter()
+            .map(|(page, k)| {
+                let paths = k.paths();
+                let len: f32 = paths.iter().map(|p| path_len(p)).sum();
+                let dur = (len / REPLAY_SPEED).clamp(0.15, 2.5);
+                let alpha = (k.freeform.alpha.clamp(0.0, 1.0) * 255.0).round() as u8;
+                let c = k.color.unwrap_or_default();
+                let width = if k.width.is_finite() { k.width.clamp(0.25, 72.0) } else { 1.0 };
+                let st = ReplayStroke { page, paths, color: Color32::from_rgba_unmultiplied(c.0, c.1, c.2, alpha), width, start, dur };
+                start += dur + REPLAY_GAP;
+                st
+            })
+            .collect();
+        if strokes.is_empty() {
+            stop_replay(app);
+            return;
+        }
+        app.canvas.ink_ui.replay = Some(Replay { strokes, t: 0.0, playing: true });
+    }
+    let dt = ctx.input(|i| i.stable_dt).clamp(0.0, 0.1);
+    if let Some(r) = app.canvas.ink_ui.replay.as_mut()
+        && r.playing
+    {
+        r.t = (r.t + dt).min(r.end());
+        if r.t >= r.end() {
+            r.playing = false;
+        }
+        ctx.request_repaint();
+    }
+}
+
+impl Replay {
+    fn end(&self) -> f32 {
+        self.strokes.last().map_or(0.0, |s| s.start + s.dur)
+    }
+    /// Strokes started so far.
+    fn started(&self) -> usize {
+        self.strokes.iter().filter(|s| s.start <= self.t).count()
+    }
+}
+
+fn path_len(p: &[[f32; 2]]) -> f32 {
+    p.windows(2).filter_map(|w| Some((w.first()?, w.get(1)?))).map(|(a, b)| (b[0] - a[0]).hypot(b[1] - a[1])).sum()
+}
+
+/// The replayed ink so far: finished strokes whole, the current one up to where it has got.
+fn paint_replay(app: &WordApp, painter: &Painter, rects: &[Rect], layout: &DocLayout, scale: f32) {
+    let Some(r) = &app.canvas.ink_ui.replay else { return };
+    for k in r.strokes.iter().filter(|k| k.start <= r.t) {
+        let Some(map) = to_screen(rects, layout, scale, k.page) else { continue };
+        let s = page_scale(rects, layout, scale, k.page).unwrap_or(scale);
+        let frac = if k.dur > 0.0 { ((r.t - k.start) / k.dur).clamp(0.0, 1.0) } else { 1.0 };
+        let total: f32 = k.paths.iter().map(|p| path_len(p)).sum();
+        let [cr, cg, cb, ca] = k.color.to_srgba_unmultiplied();
+        let color = screen_ink(app.session.view.dark_mode, wordcraft_doc::Rgb(cr, cg, cb), ca);
+        let mut left = total * frac;
+        let width = (k.width * s).max(1.0);
+        for path in &k.paths {
+            let mut pts: Vec<Pos2> = Vec::new();
+            for w in path.windows(2) {
+                let (Some(a), Some(b)) = (w.first(), w.get(1)) else { continue };
+                if pts.is_empty() {
+                    pts.push(map(*a));
+                }
+                let seg = (b[0] - a[0]).hypot(b[1] - a[1]);
+                if seg <= left {
+                    pts.push(map(*b));
+                    left -= seg;
+                } else {
+                    let f = if seg > 0.0 { left / seg } else { 0.0 };
+                    pts.push(map([a[0] + (b[0] - a[0]) * f, a[1] + (b[1] - a[1]) * f]));
+                    left = 0.0;
+                    break;
+                }
+            }
+            match (pts.as_slice(), path.as_slice()) {
+                (_, [only]) => {
+                    painter.circle_filled(map(*only), width / 2.0, color);
+                }
+                ([], _) => {}
+                _ => {
+                    painter.add(egui::Shape::line(pts, Stroke::new(width, color)));
+                }
+            }
+            if left <= 0.0 {
+                break;
+            }
+        }
+    }
+}
+
+fn stop_replay(app: &mut WordApp) {
+    app.canvas.ink_ui.replay = None;
+    let _ = app.run("draw.replay", json!({"value": false}));
+}
+
+/// Ink Replay's controls at the bottom of the document area: Rewind, Play/Pause, Forward (to
+/// the end of the stroke being drawn), how far it has got, and Close.
+pub fn replay_bar(app: &mut WordApp, ui: &Ui, area: Rect) {
+    let Some(r) = app.canvas.ink_ui.replay.as_ref() else { return };
+    let (playing, n, total) = (r.playing, r.started(), r.strokes.len());
+    let mut action = None;
+    egui::Area::new(egui::Id::new("ink_replay_bar"))
+        .order(egui::Order::Foreground)
+        .pivot(Align2::CENTER_BOTTOM)
+        .fixed_pos(pos2(area.center().x, area.max.y - 18.0))
+        .show(ui.ctx(), |ui| {
+            egui::Frame::popup(ui.style()).show(ui, |ui| {
+                ui.horizontal(|ui| {
+                    ui.spacing_mut().item_spacing = vec2(6.0, 0.0);
+                    if crate::widgets::icon_button(ui, "replayRewind", tl!("Rewind")).clicked() {
+                        action = Some("rewind");
+                    }
+                    let (icon, tip) = if playing { ("replayPause", tl!("Pause")) } else { ("replayPlay", tl!("Play")) };
+                    if crate::widgets::icon_button(ui, icon, tip).clicked() {
+                        action = Some("play");
+                    }
+                    if crate::widgets::icon_button(ui, "replayForward", tl!("Forward")).clicked() {
+                        action = Some("forward");
+                    }
+                    let label = crate::i18n::fmt(tl!("Stroke {n} of {total}"), &[("n", &n.to_string()), ("total", &total.to_string())]);
+                    ui.label(label);
+                    if crate::widgets::icon_button(ui, "close", tl!("Close")).clicked() {
+                        action = Some("close");
+                    }
+                });
+            });
+        });
+    let Some(a) = action else { return };
+    if a == "close" {
+        stop_replay(app);
+        return;
+    }
+    let Some(r) = app.canvas.ink_ui.replay.as_mut() else { return };
+    match a {
+        "rewind" => r.t = 0.0,
+        "play" if r.playing => r.playing = false,
+        "play" => {
+            // Play again from the start once it has finished.
+            if r.t >= r.end() {
+                r.t = 0.0;
+            }
+            r.playing = true;
+        }
+        _ => {
+            // Forward: finish the stroke being drawn, or the next one between strokes.
+            let t = r.t;
+            r.t = r.strokes.iter().map(|s| s.start + s.dur).find(|e| *e > t + 1e-3).unwrap_or(r.end());
+        }
+    }
+    ui.ctx().request_repaint();
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn live_ink_follows_the_dark_page() {
+        let black = wordcraft_doc::Rgb(0, 0, 0);
+        assert_eq!(screen_ink(false, black, 255), Color32::from_rgba_unmultiplied(0, 0, 0, 255));
+        // Black pen on a dark page turns light, like the saved stroke.
+        let dark = screen_ink(true, black, 128);
+        assert_eq!(dark, Color32::from_rgba_unmultiplied(255, 255, 255, 128));
     }
 }
diff --git a/crates/ui-egui/src/keys.rs b/crates/ui-egui/src/keys.rs
index 9afef5bd49..26e78d019c 100644
--- a/crates/ui-egui/src/keys.rs
+++ b/crates/ui-egui/src/keys.rs
@@ -112,17 +112,29 @@ fn dispatch(app: &mut WordApp, key: Key, m: Modifiers) -> bool {
         let _ = app.run(spec.id, json!({}));
         return true;
     }
-    // Shift extends caret movement.
+    // Shift extends caret movement; Shift+Backspace still erases (#707).
     if m.shift
         && let Some(spec) = app.session.keymap.resolve(&reg, &combo(m, name, false))
-        && spec.id.starts_with("caret.")
+        && let Some(params) = shift_variant_params(spec.id)
     {
-        let _ = app.run(spec.id, json!({"extend": true}));
+        let _ = app.run(spec.id, params);
         return true;
     }
     false
 }
 
+/// How a command bound to a plain key runs when Shift is also held and nothing is bound to the
+/// shifted combo: caret moves extend the selection, Backspace erases as usual (#707).
+fn shift_variant_params(id: &str) -> Option<Value> {
+    if id.starts_with("caret.") {
+        Some(json!({"extend": true}))
+    } else if id == "text.backspace" {
+        Some(json!({}))
+    } else {
+        None
+    }
+}
+
 /// F1–F12: shortcuts on these work without the canvas focused.
 fn is_function_key(key: Key) -> bool {
     matches!(key, Key::F1 | Key::F2 | Key::F3 | Key::F4 | Key::F5 | Key::F6 | Key::F7 | Key::F8 | Key::F9 | Key::F10 | Key::F11 | Key::F12)
@@ -258,6 +270,10 @@ pub fn canvas_events(app: &mut WordApp, ctx: &egui::Context) {
                     app.session.painter = None;
                     continue;
                 }
+                // The lasso selection and Ink Replay take Delete and Escape first.
+                if crate::ink::key(app, key) {
+                    continue;
+                }
                 // Escape puts the pen or eraser down (back to selecting).
                 if key == Key::Escape && app.session.view.draw.mode != wordcraft_engine::cmd::draw::DrawMode::Select {
                     app.canvas.ink = None;
@@ -267,6 +283,13 @@ pub fn canvas_events(app: &mut WordApp, ctx: &egui::Context) {
                 if key == Key::Escape && crate::table_pen::stop(app) {
                     continue;
                 }
+                // File › Options › Advanced: the Insert key switches overtype only when asked to.
+                if key == Key::Insert && modifiers.is_none() {
+                    if app.session.prefs.insert_key_overtype {
+                        let _ = app.run("text.overtype", json!({}));
+                    }
+                    continue;
+                }
                 if crate::objects::key(app, key, modifiers) {
                     continue;
                 }
@@ -311,6 +334,13 @@ pub fn global_shortcuts(app: &mut WordApp, ctx: &egui::Context) {
 mod tests {
     use super::*;
 
+    #[test]
+    fn shift_backspace_still_erases() {
+        assert_eq!(shift_variant_params("text.backspace"), Some(json!({})));
+        assert_eq!(shift_variant_params("caret.left"), Some(json!({"extend": true})));
+        assert_eq!(shift_variant_params("text.delete"), None);
+    }
+
     #[test]
     fn only_plain_paste_releases_paste_a_clipboard_picture() {
         let m = |command, shift, alt| egui::Modifiers { command, shift, alt, ..Default::default() };
diff --git a/crates/ui-egui/src/keytips.rs b/crates/ui-egui/src/keytips.rs
index ce037d6e4d..9f3e830c5b 100644
--- a/crates/ui-egui/src/keytips.rs
+++ b/crates/ui-egui/src/keytips.rs
@@ -192,7 +192,7 @@ fn controls(tab: &str) -> Vec<Control> {
             m("Page Number", "insert.pageNumber"),
             c("Text Box", "insert.textBox"),
             c("Quick Parts", "insert.quickParts"),
-            c("WordArt", "insert.wordArt"),
+            m("WordArt", "insert.wordArt"),
             c("Drop Cap", "insert.dropCap"),
             c("Signature Line", "insert.signatureLine"),
             c("Date & Time", "insert.dateTime"),
@@ -207,6 +207,7 @@ fn controls(tab: &str) -> Vec<Control> {
             c("Pen", "draw.pen"),
             c("Pencil", "draw.pencil"),
             c("Highlighter", "draw.highlighter"),
+            m("Add Pen", "draw.addPen"),
             c("Ink to Shape", "draw.inkToShape"),
             c("Ink to Math", "draw.inkToMath"),
             c("Drawing Canvas", "insert.canvas"),
@@ -224,6 +225,7 @@ fn controls(tab: &str) -> Vec<Control> {
             m("Page Borders", "design.pageBorders"),
         ],
         "Layout" => vec![
+            m("Text Direction", "layout.textDirection"),
             m("Margins", "layout.margins"),
             m("Orientation", "layout.orientation"),
             m("Size", "layout.size"),
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index 5185826331..472235b3ba 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -13,19 +13,34 @@ macro_rules! tl {
     };
 }
 
+pub mod a11y;
+pub mod a11y_pane;
 pub mod backstage;
 pub mod canvas;
+pub mod caret_glide;
 pub mod chrome;
+pub mod colors;
+pub mod content_controls;
 pub mod control;
 pub mod credits;
 pub mod dialogs;
+pub mod dialogs_chart;
+pub mod dialogs_controls;
 pub mod dialogs_insert;
 pub mod dialogs_keyboard;
+pub mod dialogs_layout;
 pub mod dialogs_lists;
 pub mod dialogs_notes;
 pub mod dialogs_para;
+pub mod dialogs_refs;
+pub mod dialogs_review;
 pub mod dialogs_ribbon;
+pub mod dialogs_smart_art;
+pub mod dialogs_templates;
 pub mod equation_tab;
+/// The built-in file browser, for desktops without a system file dialog (#576).
+#[cfg(not(target_arch = "wasm32"))]
+pub mod file_browser;
 pub mod file_dialogs;
 pub mod frame;
 pub mod i18n;
@@ -35,16 +50,20 @@ pub mod keys;
 pub mod keytips;
 pub mod mini_toolbar;
 pub mod objects;
+pub mod options;
 pub mod panes;
 pub mod paste_picture;
 pub mod previews;
+pub mod print_page;
 pub mod read_aloud;
 pub mod ribbon;
 pub mod scroll;
 pub mod table_pen;
+pub mod table_resize;
 pub mod theme;
 pub mod widgets;
 pub mod window_geometry;
+pub mod wordart_menus;
 pub mod zotero;
 
 use serde::{Deserialize, Serialize};
@@ -52,7 +71,7 @@ use serde_json::{Value, json};
 use wordcraft_engine::Session;
 
 pub use control::ControlRequest;
-pub use file_dialogs::FileDialogRequest;
+pub use file_dialogs::{FileDialogAnswer, FileDialogRequest, open_filters};
 
 /// Platform services injected by the host (file dialogs, file I/O).
 #[derive(Default)]
@@ -62,10 +81,11 @@ pub struct Services {
     /// Pick a path to save to, given a suggested name.
     pub pick_save: Option<Box<dyn Fn(&str) -> Option<String>>>,
     /// Desktop: show a native file dialog without blocking the UI thread (#94); used instead of
-    /// `pick_open` / `pick_save` when set. The host sends the picked path (`None` when cancelled)
-    /// through the returned channel once the user answers, and wakes the UI; a dropped sender
-    /// counts as cancelled. The app shows one dialog at a time ([`file_dialogs`]).
-    pub file_dialog: Option<Box<dyn Fn(FileDialogRequest) -> std::sync::mpsc::Receiver<Option<String>>>>,
+    /// `pick_open` / `pick_save` when set. The host sends the picked path (`Ok(None)` when
+    /// cancelled) through the returned channel once the user answers, and wakes the UI; a dropped
+    /// sender counts as cancelled. An `Err` says no system dialog could be shown, and the app shows
+    /// its built-in file browser instead (#576). The app shows one dialog at a time ([`file_dialogs`]).
+    pub file_dialog: Option<Box<dyn Fn(FileDialogRequest) -> std::sync::mpsc::Receiver<FileDialogAnswer>>>,
     /// Web: open a file picker; the file arrives later through `inbox`.
     pub open_async: Option<Box<dyn Fn(&str)>>,
     /// Web: files (name, bytes) delivered asynchronously (picker, drag and drop).
@@ -83,6 +103,20 @@ pub struct Services {
     /// Desktop: the picture on the system clipboard, if any — egui's paste only carries text
     /// (#45). Read when Paste finds no text; see [`paste_picture`].
     pub clipboard_picture: Option<Box<dyn Fn() -> Option<paste_picture::ClipboardPicture>>>,
+    /// Whether the system has animation effects on (Windows: Animation effects; macOS: Reduce
+    /// motion; Linux and the BSDs: the desktop's setting; browsers: `prefers-reduced-motion`), or
+    /// `None` when it doesn't say. What "Use system setting" follows ([`theme::Animations`]).
+    /// Asked every frame, so a change in the system's settings shows at once: the host answers
+    /// from memory and does any slow asking elsewhere. Without the hook, animation effects stay on.
+    pub animations_enabled: Option<Box<dyn Fn() -> Option<bool>>>,
+    /// Desktop: the text on the system clipboard, if any. Ctrl+V gets it from egui's paste event;
+    /// the ribbon and context-menu Paste read it here (#584).
+    pub clipboard_text: Option<Box<dyn Fn() -> Option<String>>>,
+    /// Web: keep a font the user added (stored file name, original bytes) for the next visit
+    /// (#582). Desktop fonts are stored by the font database itself, in the app's font folder.
+    pub store_font: Option<Box<dyn Fn(&str, &[u8])>>,
+    /// Web: forget a stored font (its stored file name) once the user removes it.
+    pub forget_font: Option<Box<dyn Fn(&str)>>,
 }
 
 /// Files delivered asynchronously.
@@ -95,15 +129,23 @@ pub struct UiState {
     pub tab: String,
     pub backstage: bool,
     pub backstage_page: String,
+    /// File › Print settings (#641); not saved.
+    #[serde(skip)]
+    pub print: print_page::PrintSettings,
     pub ribbon_collapsed: bool,
     pub recent: Vec<String>,
     /// Symbols inserted from the Symbol dialog, most recent first (#321).
     pub recent_symbols: Vec<dialogs_insert::RecentSymbol>,
+    /// Colours picked in the Colors dialog (More Colors…), most recent first (#606).
+    pub recent_colors: Vec<String>,
     /// Interface theme: light, dark, or follow the OS appearance (#115).
     pub theme: theme::Appearance,
     /// Interface size in percent (#475): scales the whole interface on top of the system's
     /// display scale. Junk or out-of-range saved values read as 100 % or are clamped to 80–200 %.
     pub interface_size: theme::InterfaceSize,
+    /// Animation effects (smooth scrolling, fades): on, off, or follow the system's setting, which
+    /// is the default. An unknown saved value reads as the default.
+    pub animations: theme::Animations,
     /// The dark-mode switch `ui.json` held before `theme` (#115): read once to migrate, never written.
     #[serde(rename = "dark", skip_serializing)]
     pub(crate) legacy_dark: Option<bool>,
@@ -130,24 +172,58 @@ pub struct UiState {
     /// View › Switch Modes: show pages dark (white text on black), kept between runs. Only the
     /// pages: the interface follows [`UiState::theme`] (#312).
     pub dark_page: bool,
+    /// File › Options › Advanced › Animation: the caret glides to its new place and its blink
+    /// fades, as Word's does on Windows (on, the default), or it jumps and blinks on and off
+    /// (off).
+    pub caret_animation: bool,
     /// Custom keyboard shortcuts (Customize Keyboard, #368); the session owns them while running.
     pub keyboard: wordcraft_engine::KeyMap,
     /// Custom ribbon tabs and groups, hidden tabs and the Quick Access Toolbar (Customize Ribbon,
     /// #379); the session owns them while running.
     pub ribbon: wordcraft_engine::RibbonLayout,
+    /// Caption labels the user added (References › Insert Caption › New Label), kept between
+    /// runs like Word keeps them in its Normal template (#402).
+    pub caption_labels: Vec<String>,
+    /// Draw › Add Pen: the pens added to the pen gallery; the session owns them while running.
+    /// Entries that aren't pens are dropped on reading.
+    #[serde(deserialize_with = "wordcraft_engine::cmd::draw::lenient_pens")]
+    pub ink_pens: Vec<wordcraft_engine::cmd::draw::CustomPen>,
+    /// File › Options › General: initials for comments; empty = the user name's. The session
+    /// owns them while running, like `author`.
+    pub initials: String,
+    /// The File › Options pane last shown ([`wordcraft_engine::cmd::options::PANES`]).
+    pub options_pane: String,
+    /// File › Options › Advanced: how many recent documents File › Home and Open list (0–50).
+    pub recent_count: usize,
+    /// File › Options › General: show the mini toolbar over a selection.
+    pub mini_toolbar: bool,
+    /// File › Options › Display: print the page colour (off, as in Word).
+    pub print_backgrounds: bool,
+    /// File › Options › Display: update fields (dates, page numbers, SEQ…) before printing.
+    pub update_fields_before_print: bool,
+    /// The custom dictionary (File › Options › Proofing, Add to Dictionary), kept between runs.
+    pub dictionary: Vec<String>,
 }
 
+/// Most recent documents kept (File › Options › Advanced offers 0–50, as Word does).
+pub const MAX_RECENT: usize = 50;
+/// Most custom dictionary words read back from `ui.json`.
+pub const MAX_DICTIONARY: usize = 10_000;
+
 impl Default for UiState {
     fn default() -> Self {
         UiState {
             tab: "Home".into(),
             backstage: false,
             backstage_page: "home".into(),
+            print: print_page::PrintSettings::default(),
             ribbon_collapsed: false,
             recent: Vec::new(),
             recent_symbols: Vec::new(),
+            recent_colors: Vec::new(),
             theme: theme::Appearance::default(),
             interface_size: theme::InterfaceSize::default(),
+            animations: theme::Animations::default(),
             legacy_dark: None,
             nav_tab: "headings".into(),
             show_discord: true,
@@ -160,19 +236,50 @@ impl Default for UiState {
             keytips: crate::keytips::Phase::Off,
             alt_chord_used: false,
             dark_page: false,
+            caret_animation: true,
             keyboard: wordcraft_engine::KeyMap::default(),
             ribbon: wordcraft_engine::RibbonLayout::default(),
+            caption_labels: Vec::new(),
+            ink_pens: Vec::new(),
+            initials: String::new(),
+            options_pane: "general".into(),
+            recent_count: 12,
+            mini_toolbar: true,
+            print_backgrounds: false,
+            update_fields_before_print: false,
+            dictionary: Vec::new(),
         }
     }
 }
 
+impl UiState {
+    /// Read `ui.json` leniently: a setting with a value of the wrong type (or a newer or older
+    /// version's idea of it) falls back to its default instead of discarding every setting.
+    /// `None` only when the file isn't a JSON object.
+    pub fn from_json(bytes: &[u8]) -> Option<UiState> {
+        let v: Value = serde_json::from_slice(bytes).ok()?;
+        v.is_object().then(|| options::lenient(&v))
+    }
+
+    /// How many recent documents to list.
+    pub fn recent_shown(&self) -> usize {
+        self.recent_count.min(MAX_RECENT)
+    }
+}
+
 /// The application.
 pub struct WordApp {
     pub session: Session,
     pub ui: UiState,
     pub services: Services,
     pub canvas: canvas::CanvasState,
+    /// Content control frames, check boxes and lists on the page.
+    pub controls: content_controls::ControlUi,
     pub dialog: Option<dialogs::Dialog>,
+    /// The Colors dialog (More Colors…), shown above any other dialog (#606).
+    pub colors: Option<colors::ColorsDialog>,
+    /// The Restrict Editing pane (#412).
+    pub restrict: dialogs_review::RestrictPane,
     pub status_msg: Option<(String, f64)>,
     pub previews: previews::Previews,
     /// Media key of the picture a pending Change Picture replaces (#147).
@@ -180,6 +287,12 @@ pub struct WordApp {
     /// Web: a recipient list was asked for (Select Recipients › Use an Existing List…), so the
     /// next text file from the picker loads as recipients instead of opening (#240).
     pub recipient_list_pending: bool,
+    /// The font database's [`generation`](wordcraft_fonts::FontDb::generation) last seen: when
+    /// fonts are added or removed (by any route) the font lists and the layout are refreshed.
+    font_generation: u64,
+    /// A file picked for the open dialog (Templates and Add-ins › Attach…, Organizer ›
+    /// Browse…); the dialog takes it on its next frame.
+    pub(crate) dialog_pick: Option<String>,
     /// macOS: the window has no title bar; leave room for the traffic lights.
     pub integrated_titlebar: bool,
     control_rx: Option<std::sync::mpsc::Receiver<ControlRequest>>,
@@ -202,6 +315,10 @@ pub struct WordApp {
     applied_theme: Option<theme::Appearance>,
     /// The interface language whose editing language the session last got ([`i18n::Lang::editing_lang`]).
     applied_editing: Option<i18n::Lang>,
+    /// What the system last said about its animation effects ([`Services::animations_enabled`]).
+    system_animations: Option<bool>,
+    /// Whether egui's own animations were last switched on or off ([`theme::apply_animations`]).
+    applied_animations: Option<bool>,
     pub frame_ms: f64,
     /// The window title last sent; a viewport command schedules a repaint, so only send changes.
     sent_title: String,
@@ -211,6 +328,12 @@ pub struct WordApp {
     last_autosave: f64,
     /// The tab shown before the Equation tab came up (restored when editing ends).
     pub(crate) equation_prev_tab: Option<String>,
+    /// SmartArt Text Pane: the item last focused (Promote, Demote and Add Shape act on it) and
+    /// the item being typed in (its keystrokes join one undo step).
+    pub smart_art_item: Option<usize>,
+    pub(crate) smart_art_typing: Option<usize>,
+    /// The tab shown before Outline view brought up the Outlining tab (restored when it closes).
+    pub(crate) outline_prev_tab: Option<String>,
     /// Zotero commands in flight (`ui.zotero.*`).
     pub zotero: zotero::ZoteroLink,
     /// The egui context, once the first frame has run (background work wakes the UI with it).
@@ -224,6 +347,9 @@ pub struct WordApp {
     autosave_path: Option<std::path::PathBuf>,
     /// The file dialog the host is showing, and what its answer is for ([`file_dialogs`]).
     file_dialog: Option<file_dialogs::PendingDialog>,
+    /// The built-in file browser, when it is open, and the folder it showed last (#576).
+    #[cfg(not(target_arch = "wasm32"))]
+    pub(crate) file_browser: file_browser::State,
     /// File › Info: the property field being typed in and the document revision after its last
     /// keystroke, so one visit's keystrokes make a single undo step (and anything else in
     /// between, such as an Undo, starts a new one).
@@ -256,7 +382,10 @@ impl WordApp {
             ui: UiState::default(),
             services,
             canvas: canvas::CanvasState::default(),
+            controls: Default::default(),
             dialog: None,
+            colors: None,
+            restrict: Default::default(),
             status_msg: None,
             previews: previews::Previews::default(),
             integrated_titlebar: false,
@@ -273,6 +402,8 @@ impl WordApp {
             fonts_frames: 0,
             applied_theme: None,
             applied_editing: None,
+            system_animations: None,
+            applied_animations: None,
             frame_ms: 0.0,
             sent_title: String::new(),
             quit_requested: false,
@@ -280,6 +411,9 @@ impl WordApp {
             word_count: (0, 0),
             last_autosave: 0.0,
             equation_prev_tab: None,
+            smart_art_item: None,
+            smart_art_typing: None,
+            outline_prev_tab: None,
             zotero: zotero::ZoteroLink::default(),
             ctx: None,
             read_aloud_at: None,
@@ -287,7 +421,11 @@ impl WordApp {
             autosave_path: None,
             change_picture_target: None,
             recipient_list_pending: false,
+            font_generation: wordcraft_fonts::FontDb::global().generation(),
+            dialog_pick: None,
             file_dialog: None,
+            #[cfg(not(target_arch = "wasm32"))]
+            file_browser: file_browser::State::default(),
             info_editing: None,
         }
     }
@@ -302,12 +440,15 @@ impl WordApp {
     pub fn prefs(&self) -> UiState {
         let mut ui = self.ui.clone();
         ui.author = self.session.author.clone();
+        ui.initials = self.session.initials.clone();
+        ui.dictionary = wordcraft_engine::proof::user_dictionary();
         ui.editing = self.session.prefs.clone();
         ui.read_aloud_rate = self.session.read_aloud.rate();
         ui.read_aloud_skip_citations = self.session.read_aloud.skip_citations;
         ui.dark_page = self.session.view.dark_mode;
         ui.keyboard = self.session.keymap.clone();
         ui.ribbon = self.session.ribbon.clone();
+        ui.ink_pens = self.session.view.draw.pens.clone();
         ui
     }
 
@@ -324,6 +465,13 @@ impl WordApp {
         if !author.trim().is_empty() {
             self.session.author = author;
         }
+        self.session.initials = std::mem::take(&mut self.ui.initials).chars().take(wordcraft_engine::cmd::options::MAX_INITIALS_CHARS).collect();
+        for w in std::mem::take(&mut self.ui.dictionary).iter().take(MAX_DICTIONARY) {
+            let w = w.trim();
+            if !w.is_empty() && w.chars().count() <= wordcraft_engine::cmd::options::MAX_WORD_CHARS {
+                wordcraft_engine::proof::add_word(w);
+            }
+        }
         self.session.prefs = std::mem::take(&mut self.ui.editing);
         self.session.read_aloud.set_rate(self.ui.read_aloud_rate);
         self.session.read_aloud.skip_citations = self.ui.read_aloud_skip_citations;
@@ -335,6 +483,7 @@ impl WordApp {
         // So are ribbon and toolbar commands.
         self.session.ribbon = std::mem::take(&mut self.ui.ribbon);
         self.session.ribbon.retain_known(&reg);
+        self.session.view.draw.pens = std::mem::take(&mut self.ui.ink_pens);
     }
 
     /// Run a command the user asked for (ribbon, shortcut, Backstage, file drop). New, Open,
@@ -354,6 +503,25 @@ impl WordApp {
             self.dialog = Some(dialogs::Dialog::SaveChanges { name, then: id.to_string(), params, document: self.session.document_id() });
             return Ok(json!({"pending": "saveChanges"}));
         }
+        // The ribbon and context-menu Paste commands send no text: read the system clipboard's, as
+        // Ctrl+V's paste event carries it (#584).
+        let mut params = params;
+        if matches!(id, "edit.paste" | "edit.pasteText" | "edit.pasteMerge" | "edit.pasteSpecial")
+            && params.get("text").is_none()
+            && let Some(text) = self.services.clipboard_text.as_ref().and_then(|f| f()).filter(|t| !t.is_empty())
+            && let Some(o) = params.as_object_mut()
+        {
+            // Picture files copied in a file manager reach us as their paths: paste the pictures,
+            // as Ctrl+V does.
+            if id == "edit.paste"
+                && self.session.math.is_none()
+                && paste_picture::names_picture_files(&text)
+                && let Some(r) = paste_picture::paste(self)
+            {
+                return r;
+            }
+            o.insert("text".into(), Value::String(text));
+        }
         // Paste without system clipboard text: a picture there is newer than our own copy (copying
         // here replaces it with text), so it wins (#45).
         if id == "edit.paste"
@@ -363,6 +531,10 @@ impl WordApp {
             return r;
         }
         let r = self.execute_user(id, params);
+        // Check Accessibility shows its findings in the Accessibility pane, kept up to date there.
+        if id == "file.accessibility" && r.is_ok() {
+            self.session.view.accessibility_pane = true;
+        }
         // Match Fields and Check for Errors show what they found.
         if let Ok(v) = &r
             && let Some(d) = dialogs::Dialog::report(id, v)
@@ -418,7 +590,8 @@ impl WordApp {
             // Word documents are encrypted with the document's password, if it has one.
             let password =
                 if matches!(id, "file.save" | "file.saveAs") { self.session.password.as_ref().map(wordcraft_engine::Password::as_str) } else { None };
-            let bytes = wordcraft_engine::io::save_bytes_with(&name, &self.session.doc, password)?;
+            let opts = wordcraft_engine::cmd::file::export_options(&self.session, &params);
+            let bytes = wordcraft_engine::io::save_bytes_with(&name, &self.session.doc, password, &opts)?;
             if let Some(d) = &self.services.download
                 && let Err(e) = d(&name, &bytes)
             {
@@ -452,6 +625,9 @@ impl WordApp {
         {
             self.autosave_path = self.session.path.clone();
         }
+        if let Ok(v) = &r {
+            self.keep_web_font(id, &params, v);
+        }
         self.after_command(id);
         if let Err(e) = &r {
             self.status(e.clone());
@@ -459,6 +635,44 @@ impl WordApp {
         r
     }
 
+    /// Web: store a font added from bytes, or forget the removed ones ([`Services::store_font`]).
+    fn keep_web_font(&self, id: &str, params: &Value, result: &Value) {
+        match id {
+            "font.add" => {
+                if let (Some(store), Some(file), Some(data)) =
+                    (&self.services.store_font, result.get("file").and_then(Value::as_str), params.get("data").and_then(Value::as_str))
+                    && let Some(bytes) = wordcraft_engine::cmd::insert::base64_decode(data)
+                {
+                    store(file, &bytes);
+                }
+            }
+            "font.remove" => {
+                if let Some(forget) = &self.services.forget_font {
+                    for f in result.get("removed").and_then(Value::as_array).into_iter().flatten() {
+                        if let Some(file) = f.get("file").and_then(Value::as_str) {
+                            forget(file);
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
+
+    /// Fonts were added or removed (a command, the web shell loading stored fonts): lay out
+    /// again and refresh the font lists and their previews.
+    fn watch_fonts(&mut self, ctx: &egui::Context) {
+        let db = wordcraft_fonts::FontDb::global();
+        let generation = db.generation();
+        if generation == self.font_generation {
+            return;
+        }
+        self.font_generation = generation;
+        self.session.relayout();
+        self.previews.fonts_changed(ctx, db.user_fonts().iter().flat_map(|f| f.families()));
+        ctx.request_repaint();
+    }
+
     /// Answer the Save Changes prompt: Save (through Save As for a new document) and carry on,
     /// carry on without saving, or cancel. A failed or cancelled save cancels too.
     fn answer_save_changes(&mut self, choice: SaveChoice) -> Result<Value, String> {
@@ -536,6 +750,7 @@ impl WordApp {
     }
 
     fn after_command(&mut self, id: &str) {
+        options::sync(self);
         self.canvas.caret_visible_since = now_ms();
         if !id.starts_with("view.") && !id.starts_with("document.") && !id.starts_with("format.state") {
             self.canvas.scroll_to_caret = true;
@@ -548,7 +763,7 @@ impl WordApp {
         {
             self.ui.recent.retain(|r| *r != p);
             self.ui.recent.insert(0, p);
-            self.ui.recent.truncate(12);
+            self.ui.recent.truncate(MAX_RECENT);
         }
         if !self.session.status.is_empty() {
             // Engine messages are English; the catalog translates the ones it knows.
@@ -567,6 +782,7 @@ impl WordApp {
                     self.save_as_dialog();
                 }
                 "insertPicture" => self.pick_picture(),
+                "addFont" => self.pick_font(),
                 "print" => {
                     self.ui.backstage = true;
                     self.ui.backstage_page = "print".into();
@@ -574,6 +790,9 @@ impl WordApp {
                 "options" => {
                     self.ui.backstage = true;
                     self.ui.backstage_page = "options".into();
+                    if let Some(pane) = req.get("pane").and_then(Value::as_str) {
+                        self.ui.options_pane = pane.into();
+                    }
                 }
                 "pasteSpecial" => self.dialog = Some(dialogs::Dialog::paste_special(self, req)),
                 other => self.dialog = dialogs::Dialog::open(other, self),
@@ -589,6 +808,22 @@ impl WordApp {
         self.ui.theme.is_dark(self.ctx.as_ref().and_then(egui::Context::system_theme))
     }
 
+    /// Whether animation effects are on: the Animation effects setting, where `System` follows
+    /// what the system last reported (on when it reports nothing).
+    pub fn animations_on(&self) -> bool {
+        self.ui.animations.enabled(self.system_animations)
+    }
+
+    /// What the system last said about its animation effects (`None`: it doesn't say).
+    pub fn system_animations(&self) -> Option<bool> {
+        self.system_animations
+    }
+
+    /// Ask the host for the system's animation setting.
+    fn read_system_animations(&mut self) {
+        self.system_animations = self.services.animations_enabled.as_ref().and_then(|ask| ask());
+    }
+
     /// Commands that live in the UI layer.
     fn ui_command(&mut self, id: &str, p: &Value) -> Option<Result<Value, String>> {
         let s = |k: &str| p.get(k).and_then(Value::as_str);
@@ -608,14 +843,30 @@ impl WordApp {
                 if let Some(pg) = s("page") {
                     self.ui.backstage_page = pg.into();
                 }
+                if let Some(pane) = s("pane") {
+                    self.ui.options_pane = pane.into();
+                }
                 json!({"backstage": self.ui.backstage})
             }
+            "ui.dialog" if s("name") == Some("colors") => {
+                // The font colour's More Colors… (#606); `tab`: standard or custom.
+                let target = colors::Target::cmd("format.color").remember(colors::Remember::FontColor);
+                let current =
+                    self.session.run("format.state", &json!({})).ok().and_then(|st| st.get("color").and_then(Value::as_str).and_then(colors::parse));
+                let mut d = colors::ColorsDialog::new(current, target);
+                if s("tab") == Some("custom") {
+                    d.tab = colors::ColorsTab::Custom;
+                }
+                self.colors = Some(d);
+                json!({"dialog": "colors"})
+            }
             "ui.dialog" => {
                 self.dialog = dialogs::Dialog::open(s("name").unwrap_or(""), self);
                 json!({"dialog": self.dialog.as_ref().map(|d| d.name())})
             }
             "ui.closeDialog" => {
                 self.dialog = None;
+                self.colors = None;
                 json!({})
             }
             "ui.changePicture" => {
@@ -663,6 +914,18 @@ impl WordApp {
                 }
                 json!({"percent": self.ui.interface_size.percent()})
             }
+            "ui.animations" => {
+                // `system` (follow the system's animation setting), `on` or `off`; no value reads
+                // it. `enabled` is what that comes to now, `system` what the system reports.
+                if let Some(v) = s("value") {
+                    match theme::Animations::from_code(v) {
+                        Some(a) => self.ui.animations = a,
+                        None => return Some(Err(format!("unknown animations setting {v:?}; use system, on or off"))),
+                    }
+                }
+                self.read_system_animations();
+                json!({"animations": self.ui.animations.code(), "enabled": self.animations_on(), "system": self.system_animations})
+            }
             "ui.language" => {
                 // `auto` (follow the system) or a language code; anything else is an error.
                 if let Some(v) = s("value") {
@@ -687,6 +950,14 @@ impl WordApp {
                 self.open_dialog();
                 json!({})
             }
+            // The built-in file browser (#576), for when the system's file dialog doesn't show up
+            // (desktop only): `purpose` is document (default), picture, recipients or save. A system
+            // dialog still waiting for an answer is given up as cancelled.
+            #[cfg(not(target_arch = "wasm32"))]
+            "ui.fileBrowser" => {
+                self.browse_builtin(s("purpose").unwrap_or("document"));
+                json!({"open": self.file_browser.open.is_some()})
+            }
             // Mailings › Select Recipients › Use an Existing List…: pick a CSV/TSV/text file and
             // load it as the mail-merge recipients. Opens system UI, like `ui.openFileDialog`.
             "ui.openRecipientList" => {
@@ -696,11 +967,21 @@ impl WordApp {
             // Send the document to the system print flow (web, desktop). `file.print` opens the Print
             // page; this is the button on it, and the one programmatic call that opens system UI
             // here, like `ui.openFileDialog` — only when the host can print.
-            "ui.print" => return Some(self.print_to_system()),
+            "ui.print" => return Some(self.print_to_system(p)),
             "ui.discord" => {
                 self.canvas.open_url = Some("https://discord.gg/artcraft".into());
                 json!({})
             }
+            "ui.caretAnimation" => {
+                // File › Options › Advanced › Animation: `value` true or false turns the caret's
+                // glide and fading blink on or off; no value reads it.
+                match p.get("value") {
+                    None => {}
+                    Some(Value::Bool(on)) => self.ui.caret_animation = *on,
+                    Some(_) => return Some(Err("`value` must be true or false".into())),
+                }
+                json!({"caretAnimation": self.ui.caret_animation})
+            }
             // Shape Format › Text › Create Link: the next click on an empty text box links the
             // selected box to it (`shape.link` with that box as the target); Esc cancels.
             "ui.linkTextBox" => {
@@ -715,13 +996,25 @@ impl WordApp {
     }
 
     /// `ui.print`: export the document to PDF in memory and hand it to the host's print hook.
+    /// `p` holds the print settings (`range`, `pages`, `parity`, `copies`, `collate`; see
+    /// `file.printPdf`); without any, every page prints once.
     /// An error when the host can't print (File › Print then only saves a PDF).
-    fn print_to_system(&mut self) -> Result<Value, String> {
+    fn print_to_system(&mut self, p: &Value) -> Result<Value, String> {
         if self.services.print.is_none() {
             return Err("printing to the system print dialog isn't available here; export a PDF instead".into());
         }
-        let result = wordcraft_engine::io::save_bytes("document.pdf", &self.session.doc)
-            .and_then(|bytes| self.services.print.as_ref().map_or(Ok(()), |print| print(&bytes)).map(|()| bytes.len()));
+        // File › Options › Display: fields first, and the page colour only when asked for.
+        if self.ui.update_fields_before_print
+            && let Err(e) = self.session.run("references.updateFields", &json!({}))
+        {
+            log::warn!("updating fields before printing: {e}");
+        }
+        let colour = if self.ui.print_backgrounds { None } else { self.session.doc.settings.page_color.take() };
+        let pdf = self.session.print_pdf(p).map_err(|e| e.to_string());
+        if colour.is_some() {
+            self.session.doc.settings.page_color = colour;
+        }
+        let result = pdf.and_then(|(bytes, _)| self.services.print.as_ref().map_or(Ok(()), |print| print(&bytes)).map(|()| bytes.len()));
         match result {
             Ok(len) => {
                 self.status(tl!("Opening print dialog…"));
@@ -835,12 +1128,13 @@ impl WordApp {
             self.session.set_editing_language(lang.editing_lang());
             self.applied_editing = Some(lang);
         }
+        options::sync(self);
         // Chinese text wants the Chinese face before the Japanese one (one glyph style per line).
         // An installed CJK font is read only once CJK text is shown (#241): never for an English
         // interface that doesn't open the language list.
         let system_cjk = self.fonts_system_cjk || self.want_system_cjk || lang.uses_cjk();
         if !self.styled || lang.prefers_hans() != self.fonts_hans || system_cjk != self.fonts_system_cjk {
-            theme::install_fonts_with(ctx, lang.prefers_hans(), system_cjk);
+            theme::install_fonts_extra(ctx, lang.prefers_hans(), system_cjk, &self.canvas.ime_faces);
             self.fonts_hans = lang.prefers_hans();
             self.fonts_system_cjk = system_cjk;
             // Mod with -, = and 0 are Word shortcuts (optional hyphen, subscript, paragraph spacing);
@@ -862,6 +1156,14 @@ impl WordApp {
         if ctx.zoom_factor() != zoom {
             ctx.set_zoom_factor(zoom);
         }
+        // Animation effects: the host is asked every frame what the system says (it answers from
+        // memory), so a change made in the system's settings is followed without a restart.
+        self.read_system_animations();
+        let animate = self.animations_on();
+        if self.applied_animations != Some(animate) {
+            theme::apply_animations(ctx, animate);
+            self.applied_animations = Some(animate);
+        }
         if self.ctx.is_none() {
             self.ctx = Some(ctx.clone());
         }
@@ -871,6 +1173,7 @@ impl WordApp {
         self.clear_stale_change_picture();
         let _ = self.poll_file_dialog();
         self.drain_inbox();
+        self.watch_fonts(ctx);
         self.autosave_tick(now_ms());
         if self.autosaves() && self.session.dirty {
             ctx.request_repaint_after(std::time::Duration::from_millis(1000));
@@ -892,6 +1195,8 @@ impl WordApp {
                 } else if sheet {
                     // A spreadsheet isn't a document: it's a recipient list (#334).
                     self.load_recipients(json!({"path": path}))
+                } else if wordcraft_fonts::is_font_file_name(&lp) {
+                    self.run("font.add", json!({"path": path}))
                 } else {
                     self.run("file.open", json!({"path": path}))
                 };
@@ -982,6 +1287,11 @@ impl WordApp {
         let t0 = now_ms();
         let ctx = ui.ctx().clone();
         i18n::set_current(i18n::Lang::from_pref(&self.ui.language));
+        // Animation effects off: egui's scroll areas get a wheel notch whole, not eased in.
+        if !self.animations_on() {
+            let opts = ctx.options(|o| o.input_options);
+            ctx.input_mut(|i| i.smooth_scroll_delta = scroll::unsmoothed_scroll(i, &opts));
+        }
         // Fonts installed by `logic` take effect on the next frame.
         if self.fonts_frames < 2 {
             self.fonts_frames += 1;
@@ -1003,7 +1313,11 @@ impl WordApp {
                 canvas::show(self, ui);
             });
         }
+        content_controls::popup(self, &ctx);
         dialogs::show(self, &ctx);
+        #[cfg(not(target_arch = "wasm32"))]
+        file_browser::show(self, &ctx);
+        colors::show(self, &ctx);
         zotero::show_alert(self, &ctx);
         read_aloud::show(self, &ctx);
         crate::keytips::show(self, &ctx, ui);
@@ -1029,12 +1343,15 @@ impl WordApp {
         for (name, bytes) in files {
             let lower = name.to_ascii_lowercase();
             let img = [".png", ".jpg", ".jpeg", ".gif", ".webp", ".bmp"].iter().any(|e| lower.ends_with(e));
-            let list =
-                lower.ends_with(".csv") || lower.ends_with(".tsv") || (lower.ends_with(".txt") && std::mem::take(&mut self.recipient_list_pending));
+            // Any recipient file ends the pending picker request, so a later .txt drop opens normally.
+            let asked = std::mem::take(&mut self.recipient_list_pending);
+            let list = lower.ends_with(".csv") || lower.ends_with(".tsv") || (lower.ends_with(".txt") && asked);
             let sheet = [".xlsx", ".xlsm", ".ods"].iter().any(|e| lower.ends_with(e));
+            self.recipient_list_pending = asked && !list && !sheet;
             let r = if sheet {
-                self.recipient_list_pending = false;
                 self.load_recipients(json!({"path": name, "data": wordcraft_engine::cmd::insert::base64_encode(&bytes)}))
+            } else if wordcraft_fonts::is_font_file_name(&lower) {
+                self.run("font.add", json!({"name": name, "data": wordcraft_engine::cmd::insert::base64_encode(&bytes)}))
             } else if list {
                 self.load_recipients(json!({"csv": wordcraft_engine::io::decode_text(&bytes)}))
             } else if img {
@@ -1160,7 +1477,7 @@ impl AutoSaveBlock {
 /// copy that leaves it unsaved. AutoSave writes only these formats.
 fn keeps_everything(name: &str) -> bool {
     let ext = std::path::Path::new(name).extension().map(|e| e.to_string_lossy().to_ascii_lowercase()).unwrap_or_default();
-    matches!(ext.as_str(), "docx" | "docm" | "dotx" | "dotm" | "odt" | "rtf" | "json")
+    matches!(ext.as_str(), "docx" | "docm" | "dotx" | "dotm" | "odt" | "rtf" | "json" | "xml")
 }
 
 /// The dialog a user-run command opens when it lacks the input it needs (scripts and agents get
@@ -1186,6 +1503,12 @@ fn input_dialog(id: &str, params: &Value) -> Option<&'static str> {
         "insert.field" if !has("instr") => Some("field"),
         // Edit Field Code shows the selected field's code (#339).
         "fields.setCode" if !has("code") => Some("editFieldCode"),
+        // SmartArt without a layout or items shows the layout picker.
+        "insert.smartArt" if !has("layout") && !has("items") => Some("insertSmartArt"),
+        // Chart without a type shows the gallery; Change Chart Type and Edit Data their dialogs.
+        "insert.chart" if !has("type") && !has("data") => Some("insertChart"),
+        "chart.type" if !has("type") => Some("changeChartType"),
+        "chart.editData" if !["data", "categories", "series"].into_iter().any(has) => Some("chartData"),
         // Table Properties without settings shows the dialog (with settings it applies them).
         "table.properties" if params.as_object().is_none_or(|m| m.is_empty()) => Some("tableProperties"),
         // Tabs, Borders and Shading, and Page Borders without settings show their dialogs (#320).
@@ -1197,23 +1520,48 @@ fn input_dialog(id: &str, params: &Value) -> Option<&'static str> {
         // Define New Multilevel List and Track Changes Options without settings show their dialogs.
         "list.define" if params.get("levels").is_none() => Some("defineList"),
         "review.trackingOptions" if params.as_object().is_none_or(|m| m.is_empty()) => Some("trackChangesOptions"),
+        // Compare / Combine without a revised document, AutoCorrect Options without settings and
+        // Restrict Editing without settings show their dialogs or pane (#412).
+        "review.compare" if !has("path") && !has("text") => Some("compare"),
+        "review.combine" if !has("path") && !has("text") => Some("combine"),
+        "tools.autocorrect" if params.as_object().is_none_or(|m| m.is_empty()) => Some("autoCorrect"),
+        "review.restrict" | "file.protect" if params.as_object().is_none_or(|m| m.is_empty()) => Some("restrictEditing"),
         "insert.bookmark" if !has("name") => Some("bookmark"),
         // Word Count from the keyboard or command search shows its dialog, as the ribbon does.
         "review.wordCount" if params.as_object().is_none_or(|m| m.is_empty()) => Some("wordCount"),
+        // Content control Properties without settings shows the dialog.
+        "developer.properties" if params.as_object().is_none_or(|m| m.is_empty()) => Some("controlProperties"),
         // Enclose Characters without a shape (null is one: it takes the enclosure away).
         "format.enclose" if params.get("shape").is_none() => Some("enclose"),
         // Footnote and Endnote without settings shows its dialog (#385).
         "references.noteOptions" if params.as_object().is_none_or(|m| m.is_empty()) => Some("noteOptions"),
+        // References dialogs (#402): Insert Caption, Insert Index, Mark Entry, Manage Sources and
+        // Insert Citation without a source.
+        "references.caption" | "references.index" if params.as_object().is_none_or(|m| m.is_empty()) => {
+            Some(if id == "references.caption" { "caption" } else { "index" })
+        }
+        "references.markEntry" if !has("entry") => Some("markEntry"),
+        "references.sources" if params.as_object().is_none_or(|m| m.is_empty()) => Some("sourceManager"),
+        "references.citation" if !has("tag") && !has("source") => Some("createSource"),
+        // Templates and Add-ins, and the Organizer without a file to list (#377).
+        "tools.templates" => Some("templates"),
+        "styles.organizer" if !has("path") => Some("organizer"),
+        // Language, Envelopes and Labels without settings show their dialogs (#407).
+        "review.language" if params.as_object().is_none_or(|m| m.is_empty()) => Some("language"),
+        "mailings.envelopes" if params.as_object().is_none_or(|m| m.is_empty()) => Some("envelopes"),
+        "mailings.labels" if params.as_object().is_none_or(|m| m.is_empty()) => Some("labels"),
         _ => None,
     }
 }
 
 /// User commands that replace or close the document (`file.open` without a path only shows the
 /// file picker; the open that follows is checked). Envelopes, Labels and Finish & Merge make a
-/// new document in its place; a merge written to a file (`path`) leaves it alone.
+/// new document in its place; a merge written to a file (`path`) and an envelope added to this
+/// document (`add`) leave it alone.
 fn discards_document(id: &str, params: &Value) -> bool {
     match id {
-        "file.new" | "file.close" | "mailings.envelopes" | "mailings.labels" => true,
+        "file.new" | "file.close" | "mailings.labels" => true,
+        "mailings.envelopes" => params.get("add").and_then(Value::as_bool) != Some(true),
         "file.open" => params.get("path").is_some(),
         "mailings.finish" => params.get("path").and_then(Value::as_str).is_none(),
         _ => false,
@@ -1288,6 +1636,28 @@ mod tests {
         WordApp::new(Session::new(wordcraft_doc::Document::new()), Services::default())
     }
 
+    /// File › Options › Advanced › Animation: the caret's animation is a UI command, kept between
+    /// runs.
+    #[test]
+    fn caret_animation_is_a_ui_command_and_survives_a_restart() {
+        let mut a = app();
+        assert_eq!(a.run("ui.caretAnimation", json!({})).unwrap(), json!({"caretAnimation": true}), "on by default; no value reads it");
+        assert_eq!(a.run("ui.caretAnimation", json!({"value": false})).unwrap(), json!({"caretAnimation": false}));
+        for junk in [json!({"value": "yes"}), json!({"value": 1}), json!({"value": null}), json!({"value": [true]})] {
+            assert!(a.run("ui.caretAnimation", junk).is_err());
+        }
+        assert!(!a.ui.caret_animation, "a rejected value keeps the setting");
+        let saved = serde_json::to_string(&a.prefs()).unwrap();
+        assert!(saved.contains(r#""caretAnimation":false"#), "{saved}");
+        let mut b = app();
+        b.apply_prefs(serde_json::from_str(&saved).unwrap());
+        assert!(!b.ui.caret_animation);
+        // Settings saved before the option existed leave it on.
+        let old: UiState = serde_json::from_str(r#"{"tab":"Insert"}"#).unwrap();
+        assert!(old.caret_animation && old.tab == "Insert");
+        assert_eq!(a.run("ui.caretAnimation", json!({"value": true})).unwrap()["caretAnimation"], true);
+    }
+
     /// Insert › Icons (#309) opens the icon picker from the ribbon; an id inserts without it.
     #[test]
     fn icons_button_opens_the_picker_and_ids_insert_directly() {
@@ -1478,6 +1848,227 @@ mod tests {
         assert!((a.canvas.scroll_offset.y - at - notch).abs() < 0.5, "a notch scrolls {notch}: {}", a.canvas.scroll_offset.y - at);
     }
 
+    /// An app whose host reports the system's animation setting as `system` holds it.
+    fn app_with_system_animations(system: &std::rc::Rc<std::cell::Cell<Option<bool>>>) -> WordApp {
+        let system = system.clone();
+        let services = Services { animations_enabled: Some(Box::new(move || system.get())), ..Default::default() };
+        WordApp::new(Session::new(wordcraft_doc::Document::new()), services)
+    }
+
+    /// Animation effects: "Use system setting" (the default) follows what the host reports and is
+    /// on when it reports nothing; On and Off ignore the system. The choice is kept between runs.
+    #[test]
+    fn animation_effects_setting_follows_the_system_and_survives_a_restart() {
+        use theme::Animations;
+        for (setting, system, on) in [
+            (Animations::System, None, true),
+            (Animations::System, Some(true), true),
+            (Animations::System, Some(false), false),
+            (Animations::On, Some(false), true),
+            (Animations::Off, Some(true), false),
+            (Animations::Off, None, false),
+        ] {
+            assert_eq!(setting.enabled(system), on, "{setting:?} with the system at {system:?}");
+        }
+        // No host hook (tests, headless screenshots): nothing is reported, so they are on.
+        let mut a = app();
+        assert_eq!(a.run("ui.animations", json!({})).unwrap(), json!({"animations": "system", "enabled": true, "system": null}));
+        // The system has them off, as Windows reports with Animation effects switched off.
+        let system = std::rc::Rc::new(std::cell::Cell::new(Some(false)));
+        let mut a = app_with_system_animations(&system);
+        assert_eq!(a.run("ui.animations", json!({})).unwrap(), json!({"animations": "system", "enabled": false, "system": false}));
+        assert_eq!(a.run("ui.animations", json!({"value": "On"})).unwrap()["enabled"], true);
+        system.set(Some(true));
+        assert_eq!(a.run("ui.animations", json!({"value": "off"})).unwrap(), json!({"animations": "off", "enabled": false, "system": true}));
+        assert!(a.run("ui.animations", json!({"value": "sometimes"})).is_err());
+        assert_eq!(a.ui.animations, Animations::Off, "a rejected value keeps the setting");
+        let saved = serde_json::to_string(&a.prefs()).unwrap();
+        assert!(saved.contains(r#""animations":"off""#), "{saved}");
+        let mut b = app();
+        b.apply_prefs(serde_json::from_str(&saved).unwrap());
+        assert_eq!(b.ui.animations, Animations::Off);
+        assert!(!b.animations_on());
+        // Preferences from before the setting, or with a value it doesn't know, follow the system.
+        for raw in [r#"{"tab": "Insert"}"#, r#"{"animations": "wobbly", "tab": "Insert"}"#, r#"{"animations": 3, "tab": "Insert"}"#] {
+            let ui = UiState::from_json(raw.as_bytes()).unwrap();
+            assert_eq!((ui.animations, ui.tab.as_str()), (Animations::System, "Insert"), "{raw}");
+        }
+    }
+
+    /// With the system's animation effects off (what Windows reports with Settings › Accessibility ›
+    /// Visual effects › Animation effects off), a wheel notch scrolls the page its whole distance
+    /// in one frame and egui's own fades and scroll glides are off. A change of the system's
+    /// setting is followed from the next frame.
+    #[test]
+    fn wheel_notches_land_at_once_with_animation_effects_off() {
+        let ctx = egui::Context::default();
+        let system = std::rc::Rc::new(std::cell::Cell::new(Some(false)));
+        let mut a = app_with_system_animations(&system);
+        let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1280.0, 600.0));
+        let mut t = 0.0;
+        let mut frame = |a: &mut WordApp, events: Vec<egui::Event>| {
+            t += 1.0 / 60.0;
+            let input = egui::RawInput { events, time: Some(t), screen_rect: Some(screen), ..Default::default() };
+            ctx.run_ui(input, |ui| {
+                a.logic(ui.ctx());
+                a.ui(ui);
+            })
+            .drop_without_applying_deltas();
+        };
+        for _ in 0..3 {
+            frame(&mut a, Vec::new());
+        }
+        assert!(!a.animations_on());
+        assert_eq!(ctx.global_style().animation_time, 0.0, "no fades");
+        assert_eq!(ctx.global_style().scroll_animation, egui::style::ScrollAnimation::none(), "no glide to the caret");
+        let over_page = a.canvas.canvas_rect.unwrap().center();
+        frame(&mut a, vec![egui::Event::PointerMoved(over_page)]);
+        let notch_down = || egui::Event::MouseWheel {
+            unit: egui::MouseWheelUnit::Line,
+            delta: egui::vec2(0.0, -1.0),
+            phase: egui::TouchPhase::Move,
+            modifiers: egui::Modifiers::NONE,
+        };
+        let notch = crate::scroll::notch_px(a.canvas.scale / crate::canvas::PX_PER_PT);
+        let at = a.canvas.scroll_offset.y;
+        frame(&mut a, vec![notch_down()]);
+        let landed = a.canvas.scroll_offset.y;
+        assert!((landed - at - notch).abs() < 0.5, "the whole notch ({notch}) lands in its frame: {}", landed - at);
+        for _ in 0..30 {
+            frame(&mut a, Vec::new());
+        }
+        assert_eq!(a.canvas.scroll_offset.y, landed, "nothing is left to ease in");
+        // Animation effects are switched back on in the system's settings: the next frame has it.
+        system.set(Some(true));
+        frame(&mut a, Vec::new());
+        assert!(a.animations_on());
+        assert_eq!(ctx.global_style().animation_time, egui::Style::default().animation_time);
+        assert_eq!(ctx.global_style().scroll_animation, egui::Style::default().scroll_animation);
+        frame(&mut a, vec![notch_down()]);
+        let first = a.canvas.scroll_offset.y - landed;
+        assert!(first > 0.0 && first < notch, "a notch eases in again: {first}");
+    }
+
+    /// With animation effects off a zoom step is finished in its own frame: Ctrl+wheel zooms the
+    /// notch's whole step at once, the page is already placed and drawn as it will stay, and the
+    /// status bar's zoom readout follows in the very next frame. Turns that arrive in small pieces
+    /// (a touchpad pinch on Windows) add up to a step first rather than each zooming a little.
+    #[test]
+    fn zoom_steps_land_finished_with_animation_effects_off() {
+        let ctx = egui::Context::default();
+        let system = std::rc::Rc::new(std::cell::Cell::new(Some(false)));
+        let mut a = app_with_system_animations(&system);
+        let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1280.0, 800.0));
+        let mut t = 0.0;
+        // One frame; returns how soon it asked to be drawn again.
+        let mut frame = |a: &mut WordApp, events: Vec<egui::Event>| {
+            t += 1.0 / 60.0;
+            let input = egui::RawInput { events, time: Some(t), screen_rect: Some(screen), ..Default::default() };
+            let out = ctx.run_ui(input, |ui| {
+                a.logic(ui.ctx());
+                a.ui(ui);
+            });
+            let again = out.viewport_output.values().map(|v| v.repaint_delay).min();
+            out.drop_without_applying_deltas();
+            again
+        };
+        for _ in 0..3 {
+            frame(&mut a, Vec::new());
+        }
+        let over_page = a.canvas.canvas_rect.unwrap().center();
+        frame(&mut a, vec![egui::Event::PointerMoved(over_page)]);
+        frame(&mut a, Vec::new());
+        let ctrl_wheel = |notches: f32| egui::Event::MouseWheel {
+            unit: egui::MouseWheelUnit::Line,
+            delta: egui::vec2(0.0, notches),
+            phase: egui::TouchPhase::Move,
+            modifiers: egui::Modifiers::COMMAND,
+        };
+        let opts = egui::InputOptions::default();
+        let notch_zoom = (opts.scroll_zoom_speed * opts.line_scroll_speed).exp();
+        let before = a.canvas.scale;
+        frame(&mut a, vec![ctrl_wheel(1.0)]);
+        let (scale, pages) = (a.canvas.scale, a.canvas.page_rects.clone());
+        assert!((scale / before - notch_zoom).abs() < 1e-3, "the whole notch in its frame: {before} -> {scale}");
+        for _ in 0..30 {
+            frame(&mut a, Vec::new());
+            assert_eq!(a.canvas.scale, scale, "nothing is left to ease in");
+            assert_eq!(a.canvas.page_rects, pages, "the page was already where and how it stays");
+        }
+        // Quarter notches: a step of about 10% with every second one, nothing in between.
+        frame(&mut a, vec![ctrl_wheel(-0.25)]);
+        assert_eq!(a.canvas.scale, scale, "a quarter notch isn't a step yet");
+        frame(&mut a, vec![ctrl_wheel(-0.25)]);
+        let stepped = a.canvas.scale;
+        assert!((stepped / scale - (-0.1_f32).exp()).abs() < 1e-3, "{scale} -> {stepped}");
+        for _ in 0..30 {
+            frame(&mut a, Vec::new());
+        }
+        assert_eq!(a.canvas.scale, stepped);
+        // Zoom Out (the status bar's minus, View › Zoom Out): the page changes in that frame, and
+        // the frame asks for another at once so the readout beside the slider isn't left behind.
+        assert_ne!(frame(&mut a, Vec::new()), Some(std::time::Duration::ZERO), "idle: nothing to redraw at once");
+        a.run("view.zoomOut", json!({})).unwrap();
+        assert_eq!(frame(&mut a, Vec::new()), Some(std::time::Duration::ZERO));
+        let (scale, pages) = (a.canvas.scale, a.canvas.page_rects.clone());
+        assert!(scale < stepped);
+        frame(&mut a, Vec::new());
+        assert_eq!((a.canvas.scale, &a.canvas.page_rects), (scale, &pages));
+    }
+
+    /// Issue #688: dragging a selection past the viewport's bottom edge scrolls on, and the
+    /// selection keeps growing as the content moves under the stationary pointer.
+    #[test]
+    fn dragging_a_selection_past_the_viewport_edge_auto_scrolls() {
+        let ctx = egui::Context::default();
+        let mut a = app();
+        // A few pages of text, so there is content below the fold.
+        a.run("text.insert", json!({"text": "lorem ipsum dolor sit amet consectetur ".repeat(1200)})).unwrap();
+        let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1280.0, 600.0));
+        let mut t = 0.0;
+        let mut frame = |a: &mut WordApp, events: Vec<egui::Event>| {
+            t += 1.0 / 60.0;
+            let input = egui::RawInput { events, time: Some(t), screen_rect: Some(screen), ..Default::default() };
+            ctx.run_ui(input, |ui| {
+                a.logic(ui.ctx());
+                a.ui(ui);
+            })
+            .drop_without_applying_deltas();
+        };
+        for _ in 0..3 {
+            frame(&mut a, Vec::new());
+        }
+        let (Some(vp), Some(page)) = (a.canvas.viewport, a.canvas.page_rects.first()) else { panic!("the canvas laid out") };
+        let start = page.left_top() + egui::vec2(120.0, 150.0);
+        frame(&mut a, vec![egui::Event::PointerMoved(start)]);
+        frame(
+            &mut a,
+            vec![egui::Event::PointerButton { pos: start, button: egui::PointerButton::Primary, pressed: true, modifiers: Default::default() }],
+        );
+        assert!(a.canvas.drag_selecting(), "the press started a drag-select");
+        let base = a.session.sel.focus.clone();
+        // Hold the pointer just past the viewport's bottom edge and let the frames run.
+        let below = egui::pos2(vp.center().x, vp.max.y + 40.0);
+        for _ in 0..30 {
+            frame(&mut a, vec![egui::Event::PointerMoved(below)]);
+        }
+        assert!(a.canvas.scroll_offset.y > 0.0, "the view scrolled toward later content");
+        assert!(a.session.sel.focus > base, "the selection followed the content");
+        // The pointer never moves; the content keeps scrolling under it, so the selection must
+        // keep growing.
+        let grown = a.session.sel.focus.clone();
+        for _ in 0..15 {
+            frame(&mut a, vec![egui::Event::PointerMoved(below)]);
+        }
+        assert!(a.session.sel.focus > grown, "the selection keeps growing under a stationary pointer");
+        frame(
+            &mut a,
+            vec![egui::Event::PointerButton { pos: below, button: egui::PointerButton::Primary, pressed: false, modifiers: Default::default() }],
+        );
+        assert!(!a.canvas.drag_selecting());
+        assert!(!a.session.sel.is_collapsed(), "the drag left a selection");
+    }
+
     /// Issue #123: zoomed out, pages sit side by side, and clicks map to the page under the pointer.
     #[test]
     fn zoomed_out_pages_sit_side_by_side_and_clicks_land_on_them() {
@@ -1765,6 +2356,23 @@ mod tests {
         assert!(a.status_msg.as_ref().is_some_and(|(m, _)| m.contains("blocked by the browser")), "the status bar says why");
     }
 
+    /// The print settings reach the hook: bad ones print nothing, `copies` repeats the pages.
+    #[test]
+    fn ui_print_honours_the_print_settings() {
+        let mut a = typed();
+        let sizes = std::rc::Rc::new(std::cell::RefCell::new(Vec::new()));
+        let seen = sizes.clone();
+        a.services.print = Some(Box::new(move |bytes| {
+            seen.borrow_mut().push(bytes.len());
+            Ok(())
+        }));
+        assert!(a.run("ui.print", json!({"pages": "7-9"})).is_err(), "page 7 doesn't exist");
+        assert!(a.run("ui.print", json!({"range": "nope"})).is_err());
+        assert!(sizes.borrow().is_empty(), "nothing was sent");
+        a.run("ui.print", json!({"range": "current", "copies": 3})).unwrap();
+        assert_eq!(sizes.borrow().len(), 1);
+    }
+
     /// The Print page shows the Print button only when the host can print, and the button
     /// prints through `ui.print`.
     #[test]
@@ -2027,6 +2635,15 @@ mod tests {
 
     const MAILINGS: [&str; 3] = ["mailings.envelopes", "mailings.labels", "mailings.finish"];
 
+    /// What the user gave: Envelopes and Labels without anything open their dialogs (#407).
+    fn mailing(id: &str) -> Value {
+        match id {
+            "mailings.envelopes" => json!({"delivery": "Ada"}),
+            "mailings.labels" => json!({"text": "Ada"}),
+            _ => json!({}),
+        }
+    }
+
     /// Envelopes, Labels and Finish & Merge replace the document with a new one, like New, but
     /// the ribbon ran them at once and the unsaved document was gone without a question.
     #[test]
@@ -2035,7 +2652,7 @@ mod tests {
             let mut a = typed();
             a.run("mailings.recipients", json!({"csv": "Name\nAda"})).unwrap();
             let document = a.session.document_id();
-            a.run(id, json!({})).unwrap();
+            a.run(id, mailing(id)).unwrap();
             assert_eq!(prompt(&a), Some("saveChanges"), "{id}");
             assert_eq!(a.session.document_id(), document, "{id}: untouched while the prompt is up");
 
@@ -2045,7 +2662,7 @@ mod tests {
             assert!(body_text(&a).contains(UNSAVED));
             assert!(a.session.dirty);
 
-            a.run(id, json!({})).unwrap();
+            a.run(id, mailing(id)).unwrap();
             a.run("ui.saveChanges", json!({"answer": "dontSave"})).unwrap();
             assert_eq!(prompt(&a), None);
             assert_ne!(a.session.document_id(), document, "{id}: Don't Save makes the new document");
@@ -2069,7 +2686,7 @@ mod tests {
             a.run("file.save", json!({"path": dir.join("saved.docx").to_string_lossy()})).unwrap();
             assert!(!a.session.dirty);
             let document = a.session.document_id();
-            a.run(id, json!({})).unwrap();
+            a.run(id, mailing(id)).unwrap();
             assert_eq!(prompt(&a), None, "{id}");
             assert_ne!(a.session.document_id(), document, "{id}");
         }
@@ -2097,7 +2714,7 @@ mod tests {
             assert!(a.autosaves());
             a.run("mailings.recipients", json!({"csv": "Name\nAda"})).unwrap();
             a.run("text.insert", json!({"text": "Again "})).unwrap();
-            a.run(id, json!({})).unwrap();
+            a.run(id, mailing(id)).unwrap();
             a.run("ui.saveChanges", json!({"answer": "save"})).unwrap();
             assert_eq!(prompt(&a), None);
             let saved = std::fs::read(&path).unwrap();
@@ -2173,7 +2790,7 @@ mod tests {
             a.run("file.open", json!({"path": path.to_string_lossy()})).unwrap();
             a.run("mailings.recipients", json!({"csv": "Name\nAda"})).unwrap();
             a.run("file.save", json!({})).unwrap();
-            a.run(id, json!({})).unwrap();
+            a.run(id, mailing(id)).unwrap();
             assert_eq!(prompt(&a), None, "{id}: the document was saved");
             let result = body_text(&a);
 
@@ -2719,6 +3336,50 @@ mod tests {
         let _ = std::fs::remove_dir_all(&dir);
     }
 
+    /// Add Font… (#582), web: the picker asks for fonts, the picked file arrives through the
+    /// inbox and is added, listed in the font menu and kept in the browser; removing it forgets it.
+    #[test]
+    fn a_font_picked_on_the_web_is_added_listed_and_kept() {
+        const FAMILY: &str = "Uifont Sans 3";
+        let mut font = std::fs::read(concat!(env!("CARGO_MANIFEST_DIR"), "/../../assets/fonts/SourceSans3-Regular.ttf")).unwrap();
+        let utf16 = |s: &str| s.encode_utf16().flat_map(u16::to_be_bytes).collect::<Vec<u8>>();
+        for (from, to) in [(utf16("Source Sans 3"), utf16(FAMILY)), (b"Source Sans 3".to_vec(), FAMILY.as_bytes().to_vec())] {
+            let mut i = 0;
+            while let Some(at) = font[i..].windows(from.len()).position(|w| w == from) {
+                font[i + at..i + at + to.len()].copy_from_slice(&to);
+                i += at + to.len();
+            }
+        }
+        let mut a = typed();
+        let asked = std::rc::Rc::new(std::cell::RefCell::new(String::new()));
+        let seen = asked.clone();
+        a.services.open_async = Some(Box::new(move |purpose| *seen.borrow_mut() = purpose.to_string()));
+        let kept = std::rc::Rc::new(std::cell::RefCell::new(Vec::<(String, usize)>::new()));
+        let (k1, k2) = (kept.clone(), kept.clone());
+        a.services.store_font = Some(Box::new(move |name, bytes| k1.borrow_mut().push((name.to_string(), bytes.len()))));
+        a.services.forget_font = Some(Box::new(move |name| k2.borrow_mut().retain(|(n, _)| n != name)));
+        let inbox: Inbox = std::sync::Arc::new(std::sync::Mutex::new(Vec::new()));
+        a.services.inbox = Some(inbox.clone());
+        let ctx = egui::Context::default();
+        assert!(!a.previews.families().iter().any(|f| f == FAMILY));
+        a.run("font.add", json!({})).unwrap();
+        assert_eq!(*asked.borrow(), "font");
+        inbox.lock().unwrap().push(("Uifont-Regular.ttf".into(), font.clone()));
+        a.drain_inbox();
+        a.watch_fonts(&ctx);
+        assert!(a.previews.families().iter().any(|f| f == FAMILY), "listed in the font menu at once");
+        assert_eq!(*kept.borrow(), vec![("Uifont-Regular.ttf".to_string(), font.len())]);
+        assert!(body_text(&a).contains(UNSAVED), "the document stays open");
+        // Junk named like a font is refused, and nothing is kept.
+        inbox.lock().unwrap().push(("junk.woff2".into(), b"wOF2junk".to_vec()));
+        a.drain_inbox();
+        assert_eq!(kept.borrow().len(), 1);
+        a.run("font.remove", json!({"family": FAMILY})).unwrap();
+        a.watch_fonts(&ctx);
+        assert!(kept.borrow().is_empty());
+        assert!(!a.previews.families().iter().any(|f| f == FAMILY));
+    }
+
     /// Web: the picked file arrives through the inbox and loads as recipients, even as .txt; a
     /// CSV dropped on the page does too. Anything else afterwards opens as before.
     #[test]
@@ -2739,9 +3400,45 @@ mod tests {
         inbox.lock().unwrap().push(("more.csv".into(), b"Name\nBo\nCy\n".to_vec()));
         a.drain_inbox();
         assert_eq!(a.session.merge.rows.len(), 2);
+        // A CSV picked through the picker must not turn the next .txt drop into recipients.
+        a.run("ui.openRecipientList", json!({})).unwrap();
+        inbox.lock().unwrap().push(("people.csv".into(), b"Name,City\nAda,London\n".to_vec()));
+        a.drain_inbox();
+        assert!(!a.recipient_list_pending);
+        inbox.lock().unwrap().push(("notes.txt".into(), b"A plain text document.\nAnother line.\n".to_vec()));
+        a.drain_inbox();
+        assert_eq!(prompt(&a), Some("saveChanges"), "the TXT opens like any document");
+        a.run("ui.saveChanges", json!({"answer": "dontSave"})).unwrap();
+        assert_eq!(a.session.merge.headers, vec!["Name", "City"], "the recipients stay");
+        assert!(body_text(&a).contains("A plain text document."), "the TXT opened as a document");
         // A cancelled picker leaves nothing pending once the user does something else.
         a.run("ui.openRecipientList", json!({})).unwrap();
         a.run("format.bold", json!({})).unwrap();
         assert!(!a.recipient_list_pending);
     }
+
+    /// `ui.render` and `ui.screenshot` without a `path` return the PNG in the reply instead of
+    /// writing a fixed name into the shared temporary folder, where another user could have
+    /// planted a link to one of this user's files.
+    #[test]
+    fn render_and_screenshot_without_a_path_reply_with_the_png() {
+        let ctx = egui::Context::default();
+        let mut a = typed();
+        let (req, _reply) = ControlRequest::new("ui.render", json!({"page": 1, "scale": 0.5}));
+        let control::Outcome::Done(v) = control::handle(&mut a, &ctx, &req) else { panic!("ui.render replies at once") };
+        assert_eq!(v["ok"], true, "{v}");
+        assert!(v["result"].get("path").is_none(), "no file: {v}");
+        let png = wordcraft_engine::cmd::insert::base64_decode(v["result"]["png"].as_str().expect("png")).expect("base64");
+        assert_eq!(&png[..4], b"\x89PNG", "{v}");
+        assert!(v["result"]["width"].as_u64().unwrap() > 0 && v["result"]["pages"].as_u64().unwrap() >= 1, "{v}");
+
+        let image = egui::ColorImage::from_rgba_unmultiplied([2, 1], &[255, 0, 0, 255, 0, 0, 255, 255]);
+        let v = control::save_screenshot(&image, None);
+        assert_eq!(v["ok"], true, "{v}");
+        assert!(v["result"].get("path").is_none(), "no file: {v}");
+        let png = wordcraft_engine::cmd::insert::base64_decode(v["result"]["png"].as_str().expect("png")).expect("base64");
+        assert_eq!(&png[..4], b"\x89PNG");
+        assert_eq!(v["result"]["width"], 2, "{v}");
+        assert_eq!(v["result"]["height"], 1, "{v}");
+    }
 }
diff --git a/crates/ui-egui/src/mini_toolbar.rs b/crates/ui-egui/src/mini_toolbar.rs
index 86a664d70c..2aa3524433 100644
--- a/crates/ui-egui/src/mini_toolbar.rs
+++ b/crates/ui-egui/src/mini_toolbar.rs
@@ -8,22 +8,38 @@ use serde_json::{Value, json};
 use crate::theme::Tokens;
 use crate::{WordApp, widgets};
 
-/// Height of the bar (a little taller than the ribbon's 22 pt button row).
-const BAR_H: f32 = 30.0;
 /// Vertical gap between the bar and the selection's first line.
 const VGAP: f32 = 8.0;
 /// Distance from the selection's left edge at which the bar is centred.
 const ANCHOR_INSET: f32 = 4.0;
-/// Horizontal padding inside the bar.
+/// Padding inside the bar.
 const PAD_X: f32 = 4.0;
-/// Width of the font and size combos (the ribbon's metrics).
-const COMBO_FONT_W: f32 = 150.0;
-const COMBO_SIZE_W: f32 = 52.0;
-/// Width of one icon button (the ribbon's small-button metric).
+const PAD_Y: f32 = 3.0;
+/// Height of one row of controls (the ribbon's 22 pt buttons plus a little air), and the gap
+/// between the two rows.
+const ROW_H: f32 = 24.0;
+const ROW_GAP: f32 = 2.0;
+/// Horizontal gap between neighbouring controls.
+const SPACING: f32 = 1.0;
+/// The ribbon's widget metrics: a small icon button, a split button (icon part plus its 11 pt
+/// arrow, two allocations), a group divider and the size box.
 const BTN_W: f32 = 24.0;
+const SPLIT_W: f32 = 24.0 + SPACING + 11.0;
+const SEP_W: f32 = 9.0;
+const COMBO_SIZE_W: f32 = 52.0;
+/// Gap between the size box and the grow/shrink buttons.
+const GAP: f32 = 3.0;
+/// Row 2, like Word's: B I U S | highlight, font colour | the four alignments. Fourteen
+/// allocations, so thirteen gaps; the two inside the split buttons are counted in `SPLIT_W`.
+const ROW2_W: f32 = 8.0 * BTN_W + 2.0 * SPLIT_W + 2.0 * SEP_W + 11.0 * SPACING;
+/// Row 1: font, size, grow, shrink. The font box takes what row 2 leaves, so both rows end
+/// together and the box starts at the bar's left edge.
+const COMBO_FONT_W: f32 = ROW2_W - (COMBO_SIZE_W + GAP + 2.0 * BTN_W + 3.0 * SPACING);
 
-/// Fixed bar width, so it never jitters as the selection changes.
-pub const BAR_W: f32 = PAD_X * 2.0 + COMBO_FONT_W + COMBO_SIZE_W + 3.0 + 8.0 * BTN_W + 3.0 * 9.0;
+/// The bar's size: fixed, so it never jitters as the selection changes, and wide enough for every
+/// control of both rows (#535: one row of a fixed width cut off everything after Align Left).
+pub const BAR_W: f32 = PAD_X * 2.0 + ROW2_W;
+pub const BAR_H: f32 = PAD_Y * 2.0 + ROW_H * 2.0 + ROW_GAP;
 
 /// Where the bar sits for a selection line and viewport; `None` for degenerate inputs (NaN
 /// rects must never reach egui). Pure geometry, unit tested without a window.
@@ -40,10 +56,16 @@ pub fn anchor_rect(selection_top: f32, selection_left: f32, viewport: Rect) -> O
     Some(Rect::from_min_size(pos2(x, y), Vec2::new(BAR_W, BAR_H)))
 }
 
+/// Where the bar and the controls in it were drawn last frame (`[bar, controls]`), kept in the
+/// context's memory under this id so tests can check that no control spills out of the bar.
+pub fn shown_id() -> egui::Id {
+    egui::Id::new("wc_mini_toolbar").with("shown")
+}
+
 /// Whether the bar may be shown for the current app state.
 pub fn visible(app: &WordApp) -> bool {
     // Never over a modal dialog or the Backstage.
-    if app.dialog.is_some() || app.ui.backstage {
+    if app.dialog.is_some() || app.colors.is_some() || app.ui.backstage {
         return false;
     }
     // Never while the right-click context menu is open: it owns the pointer and would double up.
@@ -82,63 +104,84 @@ pub fn show(app: &mut WordApp, ctx: &egui::Context, selection: Rect, viewport: R
         painter.rect_filled(bar.translate(Vec2::new(0.0, 2.0)), CornerRadius::same(6), t.page_shadow);
         painter.rect_filled(bar, CornerRadius::same(6), t.menu);
         painter.rect_stroke(bar, CornerRadius::same(6), egui::Stroke::new(1.0, t.border_strong), egui::StrokeKind::Inside);
-        let inner = bar.shrink2(Vec2::new(PAD_X, 0.0));
-        let mut child = ui.new_child(egui::UiBuilder::new().max_rect(inner).layout(Layout::left_to_right(Align::Center)));
-        child.spacing_mut().item_spacing = Vec2::new(1.0, 0.0);
+        let inner = bar.shrink2(Vec2::new(PAD_X, PAD_Y));
+        let mut child = ui.new_child(egui::UiBuilder::new().max_rect(inner).layout(Layout::top_down(Align::Min)));
+        child.spacing_mut().item_spacing = Vec2::new(SPACING, ROW_GAP);
         content(app, &mut child, &t);
+        let used = child.min_rect();
+        ctx.data_mut(|d| d.insert_temp(shown_id(), [bar, used]));
     });
 }
 
-/// The controls, reusing the ribbon's widgets so the bar matches the ribbon exactly.
+/// The controls in two rows like Word's mini toolbar, reusing the ribbon's widgets so the bar
+/// matches the ribbon exactly.
 fn content(app: &mut WordApp, ui: &mut egui::Ui, t: &Tokens) {
     let st: Value = app.session.run("format.state", &json!({})).unwrap_or_default();
     let flag = |k: &str| st.get(k).and_then(Value::as_bool).unwrap_or(false);
     let align = app.session.doc.para_at(&app.session.sel.focus).map(|p| app.session.doc.styles.resolve_para(&p.props).align).unwrap_or_default();
+    let row = |ui: &mut egui::Ui, app: &mut WordApp, add: &dyn Fn(&mut egui::Ui, &mut WordApp)| {
+        ui.allocate_ui_with_layout(Vec2::new(ui.available_width(), ROW_H), Layout::left_to_right(Align::Center), |ui| {
+            ui.set_min_height(ROW_H);
+            add(ui, app);
+        });
+    };
 
-    let font = st.get("font").and_then(Value::as_str).unwrap_or("").to_string();
-    let fams = app.previews.families();
-    let prev = app.previews.font_preview_fn();
-    if let Some(f) = widgets::font_combo(ui, "mini_font", COMBO_FONT_W, &font, &fams, Some(&*prev)) {
-        let _ = app.run("format.font", json!({"name": f}));
-    }
-    let size = st.get("size").and_then(Value::as_f64).map(|s| if s.fract() == 0.0 { format!("{s:.0}") } else { s.to_string() }).unwrap_or_default();
-    let sizes: Vec<String> =
-        wordcraft_engine::cmd::format::SIZES.iter().map(|s| if s.fract() == 0.0 { format!("{s:.0}") } else { s.to_string() }).collect();
-    if let Some(v) = widgets::combo(ui, "mini_size", COMBO_SIZE_W, &size, &sizes, None)
-        && let Ok(x) = v.trim().parse::<f64>()
-    {
-        let _ = app.run("format.size", json!({"size": x}));
-    }
-    ui.add_space(3.0);
-    sep(ui, t);
-
-    widgets::small(ui, app, "bold", None, "Bold", "format.bold", json!({}), flag("bold"));
-    widgets::small(ui, app, "italic", None, "Italic", "format.italic", json!({}), flag("italic"));
-    widgets::small(ui, app, "underline", None, "Underline", "format.underline", json!({}), flag("underline"));
-    widgets::small(ui, app, "strike", None, "Strikethrough", "format.strikethrough", json!({}), flag("strike"));
-    sep(ui, t);
-
-    let hl = app.canvas.last_highlight.clone();
-    widgets::split(ui, app, "highlight", "Text Highlight Color", "format.highlight", json!({"color": hl}), false, None, |ui, app| {
-        highlight_menu(ui, app);
+    row(ui, app, &|ui, app| {
+        let font = st.get("font").and_then(Value::as_str).unwrap_or("").to_string();
+        let font = app.previews.font_shown(&font);
+        let fams = app.previews.families();
+        let prev = app.previews.font_preview_fn();
+        if let Some(f) = widgets::font_combo(ui, "mini_font", COMBO_FONT_W, &font, &fams, Some(&*prev)) {
+            let _ = if f == crate::widgets::ADD_FONT {
+                app.run("font.add", json!({}))
+            } else {
+                let f = app.previews.font_stored(&f);
+                app.run("format.font", json!({"name": f}))
+            };
+        }
+        let size =
+            st.get("size").and_then(Value::as_f64).map(|s| if s.fract() == 0.0 { format!("{s:.0}") } else { s.to_string() }).unwrap_or_default();
+        let sizes: Vec<String> =
+            wordcraft_engine::cmd::format::SIZES.iter().map(|s| if s.fract() == 0.0 { format!("{s:.0}") } else { s.to_string() }).collect();
+        if let Some(v) = widgets::combo(ui, "mini_size", COMBO_SIZE_W, &size, &sizes, None)
+            && let Ok(x) = v.trim().parse::<f64>()
+        {
+            let _ = app.run("format.size", json!({"size": x}));
+        }
+        ui.add_space(GAP);
+        widgets::small(ui, app, "grow", None, "Increase Font Size", "format.growFont", json!({}), false);
+        widgets::small(ui, app, "shrink", None, "Decrease Font Size", "format.shrinkFont", json!({}), false);
     });
-    let fc = app.canvas.last_font_color.clone();
-    let sw = wordcraft_doc::Rgb::parse(&fc).map(crate::theme::c32);
-    widgets::split(ui, app, "fontcolor", "Font Color", "format.color", json!({"color": fc}), false, sw, |ui, app| {
-        font_color_menu(ui, app);
-    });
-    sep(ui, t);
 
-    use wordcraft_doc::Align as A;
-    widgets::small(ui, app, "alignLeft", None, "Align Left", "para.alignLeft", json!({}), align == A::Left);
-    widgets::small(ui, app, "alignCenter", None, "Center", "para.alignCenter", json!({}), align == A::Center);
-    widgets::small(ui, app, "alignRight", None, "Align Right", "para.alignRight", json!({}), align == A::Right);
-    widgets::small(ui, app, "justify", None, "Justify", "para.justify", json!({}), align == A::Justify);
+    row(ui, app, &|ui, app| {
+        widgets::small(ui, app, "bold", None, "Bold", "format.bold", json!({}), flag("bold"));
+        widgets::small(ui, app, "italic", None, "Italic", "format.italic", json!({}), flag("italic"));
+        widgets::small(ui, app, "underline", None, "Underline", "format.underline", json!({}), flag("underline"));
+        widgets::small(ui, app, "strike", None, "Strikethrough", "format.strikethrough", json!({}), flag("strike"));
+        sep(ui, t);
+
+        let hl = app.canvas.last_highlight.clone();
+        widgets::split(ui, app, "highlight", "Text Highlight Color", "format.highlight", json!({"color": hl}), false, None, |ui, app| {
+            highlight_menu(ui, app);
+        });
+        let fc = app.canvas.last_font_color.clone();
+        let sw = wordcraft_doc::Rgb::parse(&fc).map(crate::theme::c32);
+        widgets::split(ui, app, "fontcolor", "Font Color", "format.color", json!({"color": fc}), false, sw, |ui, app| {
+            font_color_menu(ui, app);
+        });
+        sep(ui, t);
+
+        use wordcraft_doc::Align as A;
+        widgets::small(ui, app, "alignLeft", None, "Align Left", "para.alignLeft", json!({}), align == A::Left);
+        widgets::small(ui, app, "alignCenter", None, "Center", "para.alignCenter", json!({}), align == A::Center);
+        widgets::small(ui, app, "alignRight", None, "Align Right", "para.alignRight", json!({}), align == A::Right);
+        widgets::small(ui, app, "justify", None, "Justify", "para.justify", json!({}), align == A::Justify);
+    });
 }
 
 /// A hairline divider between the bar's groups.
 fn sep(ui: &mut egui::Ui, t: &Tokens) {
-    let (r, _) = ui.allocate_exact_size(Vec2::new(9.0, 20.0), Sense::hover());
+    let (r, _) = ui.allocate_exact_size(Vec2::new(SEP_W, 20.0), Sense::hover());
     let p = ui.painter();
     p.vline(r.center().x, r.y_range().shrink(4.0), egui::Stroke::new(1.0, t.border));
 }
@@ -166,7 +209,7 @@ fn highlight_menu(ui: &mut egui::Ui, app: &mut WordApp) {
     }
 }
 
-/// Font colour: Automatic plus the standard colour grid.
+/// Font colour: Automatic, the colour grid, Recent Colors and More Colors… (#606).
 fn font_color_menu(ui: &mut egui::Ui, app: &mut WordApp) {
     egui::ScrollArea::vertical().max_height(280.0).show(ui, |ui| {
         if ui.selectable_label(false, "Automatic").clicked() {
@@ -175,11 +218,8 @@ fn font_color_menu(ui: &mut egui::Ui, app: &mut WordApp) {
             return;
         }
         let theme = app.session.doc.settings.theme_colors.clone();
-        if let Some(hex) = widgets::color_grid(ui, &theme) {
-            app.canvas.last_font_color = hex.clone();
-            let _ = app.run("format.color", json!({"color": hex}));
-            ui.close();
-        }
+        let target = crate::colors::Target::cmd("format.color").remember(crate::colors::Remember::FontColor);
+        crate::colors::menu(ui, app, &theme, target);
     });
 }
 
@@ -245,11 +285,35 @@ mod tests {
         assert!(r.min.x.is_finite() && r.min.y.is_finite());
     }
 
+    /// #535: the bar was one fixed-width row that cut off everything after Align Left. Draw it
+    /// over a real selection: every control fits inside the bar, and the bar is no wider than its
+    /// controls (both rows end together).
     #[test]
-    fn bar_width_covers_exactly_its_controls() {
-        // The position maths uses BAR_W, so it must equal the width the widgets actually take:
-        // padding + two combos + a gap + eight 24 pt buttons + three 9 pt dividers.
-        let expected = PAD_X * 2.0 + COMBO_FONT_W + COMBO_SIZE_W + 3.0 + 8.0 * BTN_W + 3.0 * 9.0;
-        assert_eq!(BAR_W, expected);
+    fn every_control_fits_inside_the_bar() {
+        use wordcraft_engine::Session;
+        let mut a = WordApp::new(Session::new(wordcraft_doc::Document::new()), Default::default());
+        a.run("text.insert", json!({"text": "The quick brown fox jumps over the lazy dog"})).unwrap();
+        a.run("select.text", json!({"text": "brown fox"})).unwrap();
+        let mut h = egui_kittest::Harness::builder().with_size(Vec2::new(1440.0, 900.0)).build_ui_state(
+            |ui, app: &mut WordApp| {
+                let ctx = ui.ctx().clone();
+                app.logic(&ctx);
+                app.ui(ui);
+            },
+            a,
+        );
+        for _ in 0..6 {
+            h.step();
+        }
+        let [bar, used] = h.ctx.data(|d| d.get_temp::<[Rect; 2]>(shown_id())).expect("the bar is shown over a selection");
+        let inner = bar.shrink2(Vec2::new(PAD_X, PAD_Y));
+        assert!(
+            inner.expand(0.1).contains_rect(used),
+            "controls {:?} spill out of the bar {:?}",
+            [used.min.x, used.min.y, used.max.x, used.max.y],
+            [inner.min.x, inner.min.y, inner.max.x, inner.max.y]
+        );
+        assert!((used.width() - inner.width()).abs() < 0.5, "the bar ({}) should be as wide as its controls ({})", inner.width(), used.width());
+        assert!(used.min.x - inner.min.x < 0.5, "the font box starts at the bar's left edge");
     }
 }
diff --git a/crates/ui-egui/src/objects.rs b/crates/ui-egui/src/objects.rs
index 54fa5224fc..044784b49a 100644
--- a/crates/ui-egui/src/objects.rs
+++ b/crates/ui-egui/src/objects.rs
@@ -6,6 +6,9 @@
 //!
 //! While dragging, nothing is laid out or rendered: the preview is the object's own pixels taken
 //! from its page's cached texture. The drop is one command, one relayout.
+//!
+//! A selected connector shows a handle at each end instead of a frame: dragging one onto a shape
+//! glues it to the nearest connection site there (`shape.connect`), elsewhere leaves it free.
 
 use egui::{Color32, Painter, Pos2, Rect, Ui};
 use serde_json::json;
@@ -33,11 +36,67 @@ pub struct ObjectDrag {
     /// Smallest size it can be resized to, points.
     min: f32,
     picture: bool,
+    /// Dragging a connector's end (false: its start, true: its end) to this page point.
+    end: Option<(bool, (f32, f32))>,
 }
 
-/// The selected object: the selection is exactly one picture, shape or text box in the body.
+/// How near (screen points) a press must be to a connector's end to grab it.
+const END_GRAB: f32 = 7.0;
+
+/// The selected connector's start and end on its page (points), and its layout.
+fn connector_ends(app: &WordApp, layout: &DocLayout) -> Option<(ObjectHit, (f32, f32), (f32, f32))> {
+    let (pos, InlineObject::Shape { kind, float, .. }) = selected(app)? else { return None };
+    if !kind.is_connector() {
+        return None;
+    }
+    let (flip_h, flip_v) = (float.flip_h, float.flip_v);
+    let o = layout.object(&pos, app.session.page_hint)?;
+    let (a, b) = wordcraft_doc::connector::ends(o.rect.x, o.rect.y, o.rect.w, o.rect.h, flip_h, flip_v);
+    Some((o, a, b))
+}
+
+fn point_on_screen(pages: &[Rect], scale: f32, page: usize, (x, y): (f32, f32)) -> Option<Pos2> {
+    pages.get(page).map(|p| egui::pos2(p.min.x + x * scale, p.min.y + y * scale))
+}
+
+/// The selected connector's end under `at` (screen): which (false: start), and the connector.
+fn connector_end_at(app: &WordApp, layout: &DocLayout, pages: &[Rect], scale: f32, at: Pos2) -> Option<(ObjectHit, bool)> {
+    let (o, a, b) = connector_ends(app, layout)?;
+    let near = |p: (f32, f32)| point_on_screen(pages, scale, o.page, p).is_some_and(|s| s.distance(at) <= END_GRAB);
+    if near(b) {
+        Some((o, true))
+    } else if near(a) {
+        Some((o, false))
+    } else {
+        None
+    }
+}
+
+/// The selected object: the selection is exactly one picture, shape or text box, in the body
+/// or in a header/footer.
 pub fn selected(app: &WordApp) -> Option<(Pos, &InlineObject)> {
-    wordcraft_engine::cmd::objects::object_selection(&app.session).filter(|(p, _)| p.story == StoryRef::Body)
+    wordcraft_engine::cmd::objects::object_selection(&app.session).filter(|(p, _)| selectable_story(app, p.story))
+}
+
+/// Whether objects of `story` can be selected and dragged on the canvas: the body and
+/// headers/footers.
+fn selectable_story(app: &WordApp, story: StoryRef) -> bool {
+    match story {
+        StoryRef::Body => true,
+        StoryRef::Part(id) => app.session.doc.parts.get(&id).is_some_and(|p| matches!(p.kind, PartKind::Header | PartKind::Footer)),
+    }
+}
+
+/// The story whose objects the canvas handles: the header/footer being edited, else the body.
+fn active_story(app: &WordApp, layout: &DocLayout) -> StoryRef {
+    let story = crate::canvas::text_box_host(app, layout).unwrap_or(app.session.sel.focus.story);
+    match story {
+        StoryRef::Body => StoryRef::Body,
+        StoryRef::Part(id) if selectable_story(app, StoryRef::Part(id)) => StoryRef::Part(id),
+        // Notes and text-box text: no top-level objects live here, so grabs find nothing and
+        // the press falls through to text handling.
+        other => other,
+    }
 }
 
 /// Whether the object under `hit` keeps its place and size: charts and diagrams can be selected
@@ -79,6 +138,21 @@ pub fn pointer(app: &mut WordApp, ui: &Ui, resp: &egui::Response, pages: &[Rect]
         if ui.input(|i| i.key_pressed(egui::Key::Escape)) {
             return true; // cancelled: dropped without a change
         }
+        if let Some((which, _)) = d.end {
+            if ui.input(|i| i.pointer.primary_down()) {
+                if let Some((_, x, y)) = crate::canvas::page_at(pages, layout, scale, at).filter(|(p, ..)| *p == d.object.page) {
+                    d.end = Some((which, (x, y)));
+                    d.drag.moved = true;
+                }
+                app.canvas.obj_drag = Some(d);
+            } else if d.drag.moved
+                && let Some((_, (x, y))) = d.end
+            {
+                let key = if which { "end" } else { "start" };
+                let _ = app.run("shape.connect", json!({key: {"x": x, "y": y, "page": d.object.page}}));
+            }
+            return true;
+        }
         if ui.input(|i| i.pointer.primary_down()) {
             let shift = ui.input(|i| i.modifiers.shift);
             if d.drag.grab == Grab::Rotate {
@@ -99,9 +173,15 @@ pub fn pointer(app: &mut WordApp, ui: &Ui, resp: &egui::Response, pages: &[Rect]
         return true;
     }
     let multi = resp.double_clicked() || resp.triple_clicked();
-    if !(pressed || multi) || crate::canvas::editing_header_footer(app, layout) {
+    if !(pressed || multi) {
         return false;
     }
+    // A selected connector's end: drag it to glue it.
+    if pressed && let Some((object, which)) = connector_end_at(app, layout, pages, scale, at) {
+        let drag = Drag::new(Grab::Move, object.page, object.rect, 0.0, at);
+        app.canvas.obj_drag = Some(ObjectDrag { drag, object, min: 0.0, picture: false, end: Some((which, (0.0, 0.0))) });
+        return true;
+    }
     let Some((object, grab)) = grab_at(app, layout, pages, scale, at) else { return false };
     // Shift/Ctrl+click adds an object to the selected ones (or takes it out), for Group.
     let adding = ui.input(|i| i.modifiers.shift || i.modifiers.command);
@@ -118,8 +198,9 @@ pub fn pointer(app: &mut WordApp, ui: &Ui, resp: &egui::Response, pages: &[Rect]
             None => return true,
         };
         // Objects in table cells can be selected and resized, not moved; charts neither.
-        if !fixed(app, &object) && (grab != Grab::Move || movable(&object)) {
-            app.canvas.obj_drag = Some(ObjectDrag { drag: Drag::new(grab, object.page, object.rect, object.spin.deg, at), object, min, picture });
+        if !fixed(app, &object) && (grab != Grab::Move || movable(app, &object)) {
+            app.canvas.obj_drag =
+                Some(ObjectDrag { drag: Drag::new(grab, object.page, object.rect, object.spin.deg, at), object, min, picture, end: None });
         }
     }
     true
@@ -146,9 +227,27 @@ fn link_click(app: &mut WordApp, layout: &DocLayout, pages: &[Rect], scale: f32,
     }
 }
 
-/// What a press at `at` would grab: a handle of the shown frame, else an object.
+/// Right-click at `at`: the picture, shape or text box under it becomes the selection (as a click
+/// would, without a drag), so the context menu acts on it. Returns whether there was one.
+pub fn select_at(app: &mut WordApp, layout: &DocLayout, pages: &[Rect], scale: f32, at: Pos2) -> bool {
+    if crate::canvas::editing_header_footer(app, layout) {
+        return false;
+    }
+    let Some((object, _)) = grab_at(app, layout, pages, scale, at) else { return false };
+    let pos = object.pos();
+    // Already selected (alone or among several picked for Group): keep the selection.
+    if !wordcraft_engine::cmd::objects::picked_objects(&app.session).contains(&pos) {
+        let end = Pos { off: pos.off + OBJ.len_utf8(), ..pos.clone() };
+        let _ = app.run("select.range", json!({"anchor": pos, "focus": end}));
+    }
+    true
+}
+
+/// What a press at `at` would grab: a handle of the shown frame, else an object of the story
+/// being edited (body, or the header/footer).
 fn grab_at(app: &WordApp, layout: &DocLayout, pages: &[Rect], scale: f32, at: Pos2) -> Option<(ObjectHit, Grab)> {
-    let handle = active(app, layout).filter(|(o, _)| o.story == StoryRef::Body && !fixed(app, o)).and_then(|(o, _)| {
+    let story = active_story(app, layout);
+    let handle = active(app, layout).filter(|(o, _)| o.story == story && !fixed(app, o)).and_then(|(o, _)| {
         let f = screen(pages, scale, o.page, o.rect)?;
         if frame::rotate_handle_at(f, o.spin.deg, at) {
             return Some((o, Grab::Rotate));
@@ -157,14 +256,16 @@ fn grab_at(app: &WordApp, layout: &DocLayout, pages: &[Rect], scale: f32, at: Po
     });
     handle.or_else(|| {
         let (page, x, y) = crate::canvas::page_at(pages, layout, scale, at)?;
-        // Selectable: body objects (table cells too); notes' objects aren't yet.
-        layout.object_at(page, x, y, EDGE / scale.max(0.01)).filter(|o| o.story == StoryRef::Body).map(|o| (o, Grab::Move))
+        // Selectable: body objects (table cells too) or the header/footer's own objects;
+        // notes' objects aren't yet.
+        layout.object_at_in(page, x, y, EDGE / scale.max(0.01), story).map(|o| (o, Grab::Move))
     })
 }
 
-/// Objects that can be dragged to a new place: those in the body's own paragraphs.
-fn movable(o: &ObjectHit) -> bool {
-    o.story == StoryRef::Body && o.path.depth() == 0
+/// Objects that can be dragged to a new place: those in the own paragraphs of the body or of a
+/// header/footer.
+fn movable(app: &WordApp, o: &ObjectHit) -> bool {
+    o.path.depth() == 0 && selectable_story(app, o.story)
 }
 
 /// Commit a finished drag as one command.
@@ -180,7 +281,9 @@ fn drop(app: &mut WordApp, d: &ObjectDrag) {
         }
         Grab::Move => json!({"page": d.drag.to_page, "x": r.x, "y": r.y}),
         // An inline object stays in the text; a floating one keeps its far edges put.
-        Grab::Resize(_) if d.object.floating() && movable(&d.object) => json!({"width": r.w, "height": r.h, "page": d.drag.page, "x": r.x, "y": r.y}),
+        Grab::Resize(_) if d.object.floating() && movable(app, &d.object) => {
+            json!({"width": r.w, "height": r.h, "page": d.drag.page, "x": r.x, "y": r.y})
+        }
         Grab::Resize(_) => json!({"width": r.w, "height": r.h}),
     };
     let _ = app.run("arrange.bounds", params);
@@ -188,6 +291,23 @@ fn drop(app: &mut WordApp, d: &ObjectDrag) {
 
 /// Draw the frame of the active object, or the drag preview.
 pub fn paint(app: &WordApp, painter: &Painter, t: &Tokens, layout: &DocLayout, pages: &[Rect], scale: f32) {
+    if let Some(d) = app.canvas.obj_drag.as_ref().filter(|d| d.end.is_some()) {
+        paint_end_drag(app, d, painter, t, layout, pages, scale);
+        return;
+    }
+    if let Some((o, a, b)) = connector_ends(app, layout) {
+        // A connector: a handle at each end (filled when glued).
+        let glued = match selected(app) {
+            Some((_, InlineObject::Shape { extra, .. })) => (extra.start.is_some(), extra.end.is_some()),
+            _ => (false, false),
+        };
+        for (p, on) in [(a, glued.0), (b, glued.1)] {
+            if let Some(c) = point_on_screen(pages, scale, o.page, p) {
+                painter.circle(c, 4.5, if on { t.accent } else { Color32::WHITE }, egui::Stroke::new(1.2, t.accent));
+            }
+        }
+        return;
+    }
     if let Some(d) = app.canvas.obj_drag.as_ref().filter(|d| d.drag.moved) {
         let Some(to) = screen(pages, scale, d.drag.to_page, d.drag.rect) else { return };
         if d.drag.grab == Grab::Rotate {
@@ -225,20 +345,60 @@ pub fn paint(app: &WordApp, painter: &Painter, t: &Tokens, layout: &DocLayout, p
     if let Some((o, editing)) = active(app, layout)
         && let Some(f) = screen(pages, scale, o.page, o.rect)
     {
-        // Handles where it can be resized and turned (body objects, not charts): else a plain
-        // frame.
-        let handles = o.story == StoryRef::Body && !fixed(app, &o);
+        // Handles where it can be resized and turned (body and header/footer objects,
+        // not charts): else a plain frame.
+        let handles = selectable_story(app, o.story) && !fixed(app, &o);
         frame::paint(painter, t, f, o.spin.deg, editing, handles, handles);
     }
 }
 
+/// A connector's end being dragged: a line from its other end to the pointer, and the connection
+/// sites of the shapes near the pointer (the one it would glue to, filled).
+fn paint_end_drag(app: &WordApp, d: &ObjectDrag, painter: &Painter, t: &Tokens, layout: &DocLayout, pages: &[Rect], scale: f32) {
+    let Some((which, at)) = d.end.filter(|_| d.drag.moved) else { return };
+    let Some((_, a, b)) = connector_ends(app, layout) else { return };
+    let fixed = if which { a } else { b };
+    let snap = wordcraft_engine::cmd::connectors::SNAP;
+    let mut best: Option<((f32, f32), f32)> = None;
+    if let Some(pg) = layout.pages.get(d.object.page) {
+        for it in &pg.items {
+            let wordcraft_layout::Placed::Object { rect, spin, story: StoryRef::Body, path, off, .. } = it else { continue };
+            let pos = Pos { story: StoryRef::Body, path: path.clone(), off: *off };
+            let Some(InlineObject::Shape { kind, .. }) = app.session.doc.para_at(&pos).and_then(|p| p.object_at(pos.off)) else { continue };
+            if kind.is_connector() || pos == d.object.pos() {
+                continue;
+            }
+            let r = [rect.x, rect.y, rect.w, rect.h];
+            // Sites of shapes the pointer is near.
+            if at.0 < rect.x - 4.0 * snap || at.0 > rect.right() + 4.0 * snap || at.1 < rect.y - 4.0 * snap || at.1 > rect.bottom() + 4.0 * snap {
+                continue;
+            }
+            for (i, _) in wordcraft_doc::connector::sites(*kind, rect.w, rect.h).iter().enumerate() {
+                let Some(p) = wordcraft_doc::connector::site_point(*kind, r, *spin, i as u32) else { continue };
+                let dist = ((p.0 - at.0).powi(2) + (p.1 - at.1).powi(2)).sqrt();
+                if let Some(c) = point_on_screen(pages, scale, d.object.page, p) {
+                    painter.circle_stroke(c, 3.5, egui::Stroke::new(1.0, t.accent));
+                }
+                if dist <= snap && best.is_none_or(|b| dist < b.1) {
+                    best = Some((p, dist));
+                }
+            }
+        }
+    }
+    let to = best.map_or(at, |b| b.0);
+    if let (Some(f), Some(e)) = (point_on_screen(pages, scale, d.object.page, fixed), point_on_screen(pages, scale, d.object.page, to)) {
+        painter.line_segment([f, e], egui::Stroke::new(1.5, t.accent));
+        painter.circle(e, 4.5, if best.is_some() { t.accent } else { Color32::WHITE }, egui::Stroke::new(1.2, t.accent));
+    }
+}
+
 /// The pointer over an object or a handle (or dragging): its cursor.
 pub fn cursor(app: &WordApp, layout: &DocLayout, pages: &[Rect], scale: f32, at: Pos2) -> Option<egui::CursorIcon> {
     if let Some(d) = &app.canvas.obj_drag {
-        return Some(d.drag.grab.cursor());
+        return Some(if d.end.is_some() { egui::CursorIcon::Crosshair } else { d.drag.grab.cursor() });
     }
-    if crate::canvas::editing_header_footer(app, layout) {
-        return None;
+    if connector_end_at(app, layout, pages, scale, at).is_some() {
+        return Some(egui::CursorIcon::Crosshair);
     }
     grab_at(app, layout, pages, scale, at).map(|(o, g)| if fixed(app, &o) { egui::CursorIcon::Default } else { g.cursor() })
 }
@@ -305,6 +465,7 @@ mod tests {
             story: None,
             freeform: None,
             effects: Default::default(),
+            extra: Default::default(),
         };
         let (app, hit) = app_with(shape);
         assert!(!fixed(&app, &hit));
diff --git a/crates/ui-egui/src/options.rs b/crates/ui-egui/src/options.rs
new file mode 100644
index 0000000000..918536ff6f
--- /dev/null
+++ b/crates/ui-egui/src/options.rs
@@ -0,0 +1,618 @@
+//! File › Options (#485): a list of panes on the left (General, Display, Proofing, Save,
+//! Language, Accessibility, Advanced, Agents), the chosen pane's settings on the right. Only
+//! settings WordCraft carries out are shown. Each pane is one function below, so a new setting
+//! goes into its pane's function. Settings agents can change too go through `file.options`; the
+//! rest live in [`crate::UiState`] (saved in `ui.json`).
+
+use std::cell::Cell;
+
+use egui::{RichText, Ui, vec2};
+use serde::Serialize;
+use serde::de::DeserializeOwned;
+use serde_json::{Map, Value, json};
+use wordcraft_engine::cmd::options::{MAX_WORD_CHARS, PANES};
+use wordcraft_geom::Unit;
+
+use crate::WordApp;
+use crate::theme::{Tokens, semibold};
+
+thread_local! {
+    // The unit dialogs and the ribbon show lengths in: File › Options › Advanced, copied from the
+    // session each frame so dialog code without the app can read it.
+    static UNIT: Cell<Unit> = const { Cell::new(Unit::Inches) };
+}
+
+/// The unit lengths are shown in (File › Options › Advanced › Measurement units).
+pub fn unit() -> Unit {
+    UNIT.get()
+}
+
+/// Copy the session's settings the UI reads without the app.
+pub(crate) fn sync(app: &WordApp) {
+    UNIT.set(app.session.prefs.units);
+}
+
+/// The units offered, with their names.
+pub const UNITS: [(Unit, &str); 5] = [
+    (Unit::Inches, "Inches"),
+    (Unit::Centimeters, "Centimeters"),
+    (Unit::Millimeters, "Millimeters"),
+    (Unit::Points, "Points"),
+    (Unit::Picas, "Picas"),
+];
+
+/// The pane names, in [`PANES`] order.
+fn pane_label(id: &str) -> &'static str {
+    match id {
+        "display" => "Display",
+        "proofing" => "Proofing",
+        "save" => "Save",
+        "language" => "Language",
+        "accessibility" => "Accessibility",
+        "advanced" => "Advanced",
+        "agents" => "Agents",
+        _ => "General",
+    }
+}
+
+/// The Options page.
+pub fn page(app: &mut WordApp, ui: &mut Ui) {
+    let t = Tokens::get(ui.ctx());
+    ui.label(RichText::new(tl!("Options")).font(semibold(26.0)));
+    ui.add_space(16.0);
+    let current = if PANES.contains(&app.ui.options_pane.as_str()) { app.ui.options_pane.clone() } else { "general".to_string() };
+    ui.horizontal_top(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(170.0);
+            for id in PANES {
+                let label = tl!(pane_label(id));
+                let active = current == id;
+                let (r, resp) = ui.allocate_exact_size(vec2(170.0, 30.0), egui::Sense::click());
+                resp.widget_info(|| egui::WidgetInfo::selected(egui::WidgetType::SelectableLabel, true, active, label));
+                if active {
+                    ui.painter().rect_filled(r, 4.0, t.checked);
+                } else if resp.hovered() {
+                    ui.painter().rect_filled(r, 4.0, t.hover);
+                }
+                let font = if active { semibold(14.0) } else { crate::theme::regular(14.0) };
+                ui.painter().text(egui::pos2(r.min.x + 12.0, r.center().y), egui::Align2::LEFT_CENTER, label, font, t.text);
+                if resp.clicked() {
+                    app.ui.options_pane = id.to_string();
+                }
+            }
+        });
+        ui.add_space(12.0);
+        let (line, _) = ui.allocate_exact_size(vec2(1.0, 420.0), egui::Sense::hover());
+        ui.painter().rect_filled(line, 0.0, t.border);
+        ui.add_space(20.0);
+        ui.vertical(|ui| {
+            ui.set_max_width(640.0);
+            match current.as_str() {
+                "display" => display(app, ui),
+                "proofing" => proofing(app, ui),
+                "save" => save(app, ui),
+                "language" => language(app, ui),
+                "accessibility" => accessibility(app, ui),
+                "advanced" => advanced(app, ui),
+                "agents" => agents(ui),
+                _ => general(app, ui),
+            }
+        });
+    });
+}
+
+fn section(ui: &mut Ui, title: &str) {
+    ui.add_space(6.0);
+    ui.label(RichText::new(tl!(title)).font(semibold(15.0)));
+    ui.add_space(2.0);
+}
+
+fn note(ui: &mut Ui, text: &str) {
+    ui.label(RichText::new(tl!(text)).small().weak());
+}
+
+/// Change settings through `file.options` (the command agents use).
+fn set(app: &mut WordApp, params: Value) {
+    if let Err(e) = app.run("file.options", params) {
+        app.status(e);
+    }
+}
+
+/// A checkbox for a `file.options` on/off setting.
+fn flag(app: &mut WordApp, ui: &mut Ui, label: &str, key: &str, value: bool) {
+    let mut v = value;
+    if ui.checkbox(&mut v, tl!(label)).changed() {
+        set(app, json!({ key: v }));
+    }
+}
+
+fn general(app: &mut WordApp, ui: &mut Ui) {
+    section(ui, "Interface");
+    theme_picker(app, ui);
+    interface_size_picker(app, ui);
+    ui.checkbox(&mut app.ui.mini_toolbar, tl!("Show the mini toolbar when text is selected"));
+    let mut dark_page = app.session.view.dark_mode;
+    if ui
+        .checkbox(&mut dark_page, tl!("Dark page (white text on black)"))
+        .on_hover_text(tl!("Show documents with their colours inverted, like View › Switch Modes. Saving, printing and PDFs are unchanged."))
+        .changed()
+    {
+        let _ = app.run("view.darkMode", json!({"value": dark_page}));
+    }
+    ui.checkbox(&mut app.ui.show_discord, tl!("Show the community button in the title bar"));
+    ui.add_space(8.0);
+    section(ui, "Personalize");
+    egui::Grid::new("options_user").num_columns(2).spacing(vec2(8.0, 6.0)).show(ui, |ui| {
+        ui.label(tl!("User name:"));
+        let mut n = app.session.author.clone();
+        if ui.add(egui::TextEdit::singleline(&mut n).desired_width(260.0)).changed() {
+            app.session.author = n;
+        }
+        ui.end_row();
+        ui.label(tl!("Initials:"));
+        let mut i = app.session.initials.clone();
+        let hint = app.session.user_initials();
+        if ui
+            .add(
+                egui::TextEdit::singleline(&mut i).desired_width(80.0).char_limit(wordcraft_engine::cmd::options::MAX_INITIALS_CHARS).hint_text(hint),
+            )
+            .changed()
+        {
+            set(app, json!({"initials": i}));
+        }
+        ui.end_row();
+    });
+    note(ui, "New comments and tracked changes are recorded under this name and these initials.");
+}
+
+fn display(app: &mut WordApp, ui: &mut Ui) {
+    section(ui, "Formatting marks");
+    note(ui, "These marks show even when Show/Hide ¶ is off.");
+    let m = app.session.prefs.marks;
+    for (label, key, on) in [
+        ("Tab characters", "tabs", m.tabs),
+        ("Spaces", "spaces", m.spaces),
+        ("Paragraph marks", "paragraphs", m.paragraphs),
+        ("Hidden text", "hidden", m.hidden),
+    ] {
+        let mut v = on;
+        if ui.checkbox(&mut v, tl!(label)).changed() {
+            set(app, json!({"marks": { key: v }}));
+        }
+    }
+    let mut marks = app.session.view.marks;
+    if ui.checkbox(&mut marks, tl!("Show all formatting marks")).changed() {
+        let _ = app.run("view.marks", json!({"value": marks}));
+    }
+    ui.add_space(8.0);
+    section(ui, "Page display");
+    let mut ruler = app.session.view.ruler;
+    if ui.checkbox(&mut ruler, tl!("Show rulers")).changed() {
+        let _ = app.run("view.ruler", json!({"value": ruler}));
+    }
+    ui.add_space(8.0);
+    section(ui, "Printing");
+    ui.checkbox(&mut app.ui.print_backgrounds, tl!("Print the page color"));
+    ui.checkbox(&mut app.ui.update_fields_before_print, tl!("Update fields before printing"));
+}
+
+fn proofing(app: &mut WordApp, ui: &mut Ui) {
+    // #476 (AutoCorrect Options…) goes here, at the top.
+    section(ui, "Spelling");
+    let pr = app.session.prefs.clone();
+    flag(app, ui, "Ignore words in capitals", "ignoreUppercase", pr.ignore_uppercase);
+    flag(app, ui, "Ignore words with numbers", "ignoreNumbers", pr.ignore_numbers);
+    flag(app, ui, "Ignore web and file addresses", "ignoreInternet", pr.ignore_internet);
+    ui.add_space(8.0);
+    section(ui, "As you type");
+    let spelling = app.session.view.proofing;
+    flag(app, ui, "Check spelling as you type", "checkSpelling", spelling);
+    ui.add_enabled_ui(app.session.view.proofing, |ui| flag(app, ui, "Mark grammar errors as you type", "markGrammar", pr.mark_grammar));
+    ui.add_space(8.0);
+    section(ui, "Custom dictionary");
+    custom_dictionary(app, ui);
+}
+
+/// The custom dictionary: the words Add to Dictionary kept, each with a Remove button, and a
+/// field to add one.
+fn custom_dictionary(app: &mut WordApp, ui: &mut Ui) {
+    let words = wordcraft_engine::proof::user_dictionary();
+    if words.is_empty() {
+        note(ui, "No words yet. Add to Dictionary on a misspelled word puts it here.");
+    }
+    egui::ScrollArea::vertical().id_salt("options_dictionary").max_height(180.0).show(ui, |ui| {
+        for w in &words {
+            ui.horizontal(|ui| {
+                ui.allocate_ui_with_layout(vec2(220.0, 20.0), egui::Layout::left_to_right(egui::Align::Center), |ui| {
+                    ui.set_min_width(220.0);
+                    ui.add(egui::Label::new(w.as_str()).truncate());
+                });
+                if ui.small_button(tl!("Remove")).clicked() {
+                    set(app, json!({"removeWords": [w]}));
+                }
+            });
+        }
+    });
+    let id = egui::Id::new("options_dictionary_new");
+    let mut word = ui.data(|d| d.get_temp::<String>(id)).unwrap_or_default();
+    ui.horizontal(|ui| {
+        let r = ui.add(egui::TextEdit::singleline(&mut word).desired_width(220.0).char_limit(MAX_WORD_CHARS).hint_text(tl!("New word")));
+        let enter = r.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter));
+        let w = word.trim().to_string();
+        let ok = !w.is_empty() && !w.chars().any(char::is_whitespace);
+        if (ui.add_enabled(ok, egui::Button::new(tl!("Add"))).clicked() || (enter && ok)) && app.run("file.options", json!({"addWords": [w]})).is_ok()
+        {
+            word.clear();
+        }
+    });
+    ui.data_mut(|d| d.insert_temp(id, word));
+}
+
+fn save(app: &mut WordApp, ui: &mut Ui) {
+    section(ui, "Save documents");
+    // The browser can't write to the user's files, so AutoSave can't be turned on there (#176).
+    let browser = app.autosave_block() == Some(crate::AutoSaveBlock::Browser);
+    let mut autosave = app.autosave && !browser;
+    let r = ui.add_enabled(!browser, egui::Checkbox::new(&mut autosave, tl!("AutoSave documents you have saved in WordCraft")));
+    if browser {
+        r.on_disabled_hover_text(crate::AutoSaveBlock::Browser.reason());
+    } else if r.changed() {
+        app.autosave = autosave;
+        app.session.autosave = autosave;
+    }
+    note(ui, "AutoSave writes your changes to the file a moment after you stop typing.");
+}
+
+fn language(app: &mut WordApp, ui: &mut Ui) {
+    section(ui, "Interface language");
+    language_picker(app, ui);
+    // #414 (detect the document's language) goes here.
+    ui.add_space(8.0);
+    section(ui, "Proofing language");
+    note(ui, "Spelling and grammar are checked in English (United States).");
+}
+
+fn accessibility(app: &mut WordApp, ui: &mut Ui) {
+    use wordcraft_engine::speech::{MAX_RATE, MIN_RATE};
+    section(ui, "Visual effects");
+    animations_picker(app, ui);
+    ui.add_space(8.0);
+    section(ui, "Read Aloud");
+    let mut rate = app.session.read_aloud.rate();
+    ui.horizontal(|ui| {
+        ui.label(tl!("Speed"));
+        let r = ui.add(egui::Slider::new(&mut rate, MIN_RATE..=MAX_RATE).step_by(0.05).custom_formatter(|v, _| format!("{v:.2}×")));
+        if r.changed() {
+            let _ = app.run("readAloud.speed", json!({"value": rate}));
+        }
+    });
+    let mut skip = app.session.read_aloud.skip_citations;
+    if ui.checkbox(&mut skip, tl!("Skip citations & bibliography")).changed() {
+        let _ = app.run("readAloud.skipCitations", json!({"value": skip}));
+    }
+}
+
+fn advanced(app: &mut WordApp, ui: &mut Ui) {
+    section(ui, "Editing");
+    let pr = app.session.prefs.clone();
+    flag(app, ui, "Typing replaces selected text", "typingReplacesSelection", pr.typing_replaces_selection);
+    flag(app, ui, "Use the Insert key to switch overtype on and off", "insertKeyOvertype", pr.insert_key_overtype);
+    flag(app, ui, "Overtype (typing replaces the characters after the caret)", "overtype", pr.overtype);
+    ui.add_space(8.0);
+    section(ui, "Display");
+    egui::Grid::new("options_display").num_columns(2).spacing(vec2(8.0, 6.0)).show(ui, |ui| {
+        ui.label(tl!("Recent documents to show:"));
+        let mut n = app.ui.recent_shown();
+        if ui.add(egui::DragValue::new(&mut n).range(0..=crate::MAX_RECENT).speed(0.2)).changed() {
+            app.ui.recent_count = n;
+        }
+        ui.end_row();
+        ui.label(tl!("Measurement units:"));
+        let name = UNITS.iter().find(|(u, _)| *u == pr.units).map_or("Inches", |(_, n)| n);
+        egui::ComboBox::from_id_salt("options_units").selected_text(tl!(name)).width(160.0).show_ui(ui, |ui| {
+            for (u, label) in UNITS {
+                if ui.selectable_label(pr.units == u, tl!(label)).clicked() {
+                    set(app, json!({"units": u}));
+                }
+            }
+        });
+        ui.end_row();
+    });
+    ui.add_space(8.0);
+    section(ui, "Animation");
+    let mut caret = app.ui.caret_animation;
+    if ui
+        .checkbox(&mut caret, tl!("Animate the caret (it glides and fades)"))
+        .on_hover_text(tl!(
+            "On: the caret glides to its new place when you type or use the arrow keys, and its blink fades. Off: it jumps and blinks on and off."
+        ))
+        .changed()
+    {
+        let _ = app.run("ui.caretAnimation", json!({"value": caret}));
+    }
+    ui.add_space(8.0);
+    section(ui, "Customize");
+    ui.horizontal(|ui| {
+        ui.label(tl!("Keyboard shortcuts:"));
+        if ui.button(tl!("Customize…")).clicked() {
+            let _ = app.run("tools.customizeKeyboard", json!({}));
+        }
+    });
+    ui.horizontal(|ui| {
+        ui.label(tl!("Ribbon and Quick Access Toolbar:"));
+        if ui.button(tl!("Customize…")).clicked() {
+            let _ = app.run("tools.customizeRibbon", json!({}));
+        }
+    });
+}
+
+fn agents(ui: &mut Ui) {
+    section(ui, "Agents");
+    ui.label(tl!("Every command is available to scripts and AI agents: run `wordcraft-cli mcp` for an MCP server, or start the app with `--control <port>` for the JSON control channel."));
+}
+
+/// Interface theme: Light, Dark, or follow the system's appearance (#115).
+fn theme_picker(app: &mut WordApp, ui: &mut Ui) {
+    use crate::theme::Appearance;
+    ui.horizontal(|ui| {
+        ui.label(tl!("Interface theme:"));
+        egui::ComboBox::from_id_salt("interface_theme").selected_text(tl!(app.ui.theme.label())).width(220.0).show_ui(ui, |ui| {
+            for a in Appearance::ALL {
+                if ui.selectable_label(app.ui.theme == a, tl!(a.label())).clicked() {
+                    let _ = app.run("ui.theme", json!({"value": a.code()}));
+                }
+            }
+        });
+    });
+}
+
+/// Interface size: 80–200 %, on top of the system's display scale (#475).
+fn interface_size_picker(app: &mut WordApp, ui: &mut Ui) {
+    use crate::theme::InterfaceSize;
+    let current = app.ui.interface_size.percent();
+    ui.horizontal(|ui| {
+        ui.label(tl!("Interface size:"));
+        egui::ComboBox::from_id_salt("interface_size").selected_text(format!("{current}%")).width(220.0).show_ui(ui, |ui| {
+            for pct in InterfaceSize::PRESETS {
+                if ui.selectable_label(current == pct, format!("{pct}%")).clicked() {
+                    let _ = app.run("ui.interfaceSize", json!({"percent": pct}));
+                }
+            }
+        });
+    });
+    ui.label(
+        RichText::new(tl!(
+            "Makes the ribbon, menus and dialogs larger or smaller, on top of your system's display scaling. Document zoom is separate."
+        ))
+        .small()
+        .weak(),
+    );
+}
+
+/// Animation effects: on, off, or follow the system's setting (the default). Under "Use system
+/// setting" a line says what the system reports, so it is plain what the choice comes to here.
+fn animations_picker(app: &mut WordApp, ui: &mut Ui) {
+    use crate::theme::Animations;
+    ui.horizontal(|ui| {
+        ui.label(tl!("Animation effects:"));
+        egui::ComboBox::from_id_salt("animation_effects").selected_text(tl!(app.ui.animations.label())).width(220.0).show_ui(ui, |ui| {
+            for a in Animations::ALL {
+                if ui.selectable_label(app.ui.animations == a, tl!(a.label())).clicked() {
+                    let _ = app.run("ui.animations", json!({"value": a.code()}));
+                }
+            }
+        });
+    });
+    note(ui, "Smooth scrolling and zooming, and menus and buttons that fade in. Off shows every change at once.");
+    if app.ui.animations == Animations::System {
+        let reported = match app.system_animations() {
+            Some(true) => "Your system has animation effects turned on.",
+            Some(false) => "Your system has animation effects turned off.",
+            None => "Your system doesn't report an animation setting, so animation effects stay on.",
+        };
+        note(ui, reported);
+    }
+}
+
+/// Interface language: follow the system (the default) or pick one (#8).
+fn language_picker(app: &mut WordApp, ui: &mut Ui) {
+    use crate::i18n::{AUTO, Lang};
+    // The language names are in their own scripts: fonts for them load from the next frame.
+    app.want_system_cjk = true;
+    let system = crate::i18n::system_lang();
+    let auto_label = crate::i18n::fmt(tl!("Automatic ({language})"), &[("language", system.name())]);
+    let current = if app.ui.language == AUTO { auto_label.clone() } else { Lang::from_pref(&app.ui.language).name().to_string() };
+    ui.horizontal(|ui| {
+        ui.label(tl!("Interface language:"));
+        egui::ComboBox::from_id_salt("interface_language").selected_text(current).width(220.0).show_ui(ui, |ui| {
+            if ui.selectable_label(app.ui.language == AUTO, auto_label.as_str()).clicked() {
+                let _ = app.run("ui.language", json!({"value": AUTO}));
+            }
+            for lang in Lang::all() {
+                if ui.selectable_label(app.ui.language == lang.code(), lang.name()).clicked() {
+                    let _ = app.run("ui.language", json!({"value": lang.code()}));
+                }
+            }
+        });
+    });
+    ui.label(RichText::new(tl!("Automatic follows your system's language. Menus and commands change; your documents don't.")).small().weak());
+}
+
+/// Deserialize `input` over `T`'s defaults one setting at a time: a value of the wrong type is
+/// dropped (its default stays) instead of failing the whole read. Objects nest (`editing`).
+pub fn lenient<T: Serialize + DeserializeOwned + Default>(input: &Value) -> T {
+    let mut base = serde_json::to_value(T::default()).unwrap_or(Value::Null);
+    if base.is_object() {
+        overlay::<T>(&mut base, &mut Vec::new(), input, 0);
+    }
+    serde_json::from_value(base).unwrap_or_default()
+}
+
+/// The object at `path` inside `root`.
+fn object_at<'a>(root: &'a mut Value, path: &[String]) -> Option<&'a mut Map<String, Value>> {
+    let mut v = root;
+    for k in path {
+        v = v.as_object_mut()?.get_mut(k)?;
+    }
+    v.as_object_mut()
+}
+
+fn overlay<T: DeserializeOwned>(root: &mut Value, path: &mut Vec<String>, input: &Value, depth: usize) {
+    let Some(map) = input.as_object() else { return };
+    for (k, v) in map {
+        let Some(parent) = object_at(root, path) else { return };
+        let old = parent.get(k).cloned();
+        if depth < 4 && v.is_object() && old.as_ref().is_some_and(Value::is_object) {
+            path.push(k.clone());
+            overlay::<T>(root, path, v, depth + 1);
+            path.pop();
+            continue;
+        }
+        parent.insert(k.clone(), v.clone());
+        if serde_json::from_value::<T>(root.clone()).is_err()
+            && let Some(parent) = object_at(root, path)
+        {
+            match old {
+                Some(o) => parent.insert(k.clone(), o),
+                None => parent.remove(k),
+            };
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use egui_kittest::kittest::Queryable;
+    use serde_json::json;
+    use wordcraft_geom::Unit;
+
+    use crate::theme::Appearance;
+    use crate::{Services, UiState, WordApp};
+
+    fn app() -> WordApp {
+        WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Services::default())
+    }
+
+    /// File › Options settings come back after a restart, and a `ui.json` with a wrong value in
+    /// one setting keeps every other setting (#485).
+    #[test]
+    fn options_survive_a_restart_and_junk_in_ui_json() {
+        let mut a = app();
+        a.run(
+            "file.options",
+            json!({"initials": "VK", "units": "centimeters", "typingReplacesSelection": false, "marks": {"tabs": true}, "ignoreNumbers": false, "addWords": ["zqxoptionsword"]}),
+        )
+        .unwrap();
+        a.ui.recent_count = 30;
+        a.ui.print_backgrounds = true;
+        let saved = serde_json::to_vec(&a.prefs()).unwrap();
+        let mut b = app();
+        b.apply_prefs(UiState::from_json(&saved).unwrap());
+        assert_eq!(b.session.prefs, a.session.prefs);
+        assert_eq!(b.session.prefs.units, Unit::Centimeters);
+        assert_eq!(b.session.initials, "VK");
+        assert_eq!((b.ui.recent_count, b.ui.print_backgrounds), (30, true));
+        assert!(wordcraft_engine::proof::user_dictionary().contains(&"zqxoptionsword".to_string()));
+
+        let junk = br#"{"theme": "dark", "recentCount": "lots", "printBackgrounds": 7, "optionsPane": ["x"], "dark": true,
+            "editing": {"units": "furlongs", "typingReplacesSelection": false, "marks": {"tabs": "yes", "spaces": true}}}"#;
+        let ui = UiState::from_json(junk).unwrap();
+        assert_eq!(ui.theme, Appearance::Dark);
+        assert_eq!((ui.recent_count, ui.print_backgrounds, ui.options_pane.as_str()), (12, false, "general"));
+        assert_eq!(ui.legacy_dark, Some(true));
+        assert_eq!(ui.editing.units, Unit::Inches);
+        assert!(!ui.editing.typing_replaces_selection);
+        assert!(ui.editing.marks.spaces && !ui.editing.marks.tabs);
+        assert!(UiState::from_json(b"[1, 2]").is_none() && UiState::from_json(b"not json").is_none());
+    }
+
+    /// `file.options` opens the page at a pane; the pane list switches panes, and their
+    /// checkboxes change the settings (#485).
+    #[test]
+    fn options_panes_open_and_change_settings() {
+        let mut a = app();
+        a.run("file.options", json!({"pane": "display"})).unwrap();
+        assert!(a.ui.backstage);
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
+            |ui, app: &mut WordApp| {
+                let ctx = ui.ctx().clone();
+                app.logic(&ctx);
+                app.ui(ui);
+            },
+            a,
+        );
+        h.run_steps(4);
+        h.get_by_label("Spaces").click();
+        h.run_steps(2);
+        assert!(h.state().session.prefs.marks.spaces, "Display › Spaces");
+        h.get_by_label("Proofing").click();
+        h.run_steps(4);
+        assert_eq!(h.state().ui.options_pane, "proofing");
+        h.get_by_label("Ignore words in capitals").click();
+        h.run_steps(2);
+        assert!(!h.state().session.prefs.ignore_uppercase);
+        h.get_by_label("Advanced").click();
+        h.run_steps(4);
+        h.get_by_label("Typing replaces selected text").click();
+        h.run_steps(2);
+        assert!(!h.state().session.prefs.typing_replaces_selection);
+        assert!(h.query_by_label("Measurement units:").is_some());
+    }
+
+    /// File › Options › Accessibility › Animation effects: Use system setting (the default), On
+    /// or Off, with a line saying what the system's own setting is while it is followed.
+    #[test]
+    fn animation_effects_is_an_accessibility_option() {
+        use crate::theme::Animations;
+        let services = Services { animations_enabled: Some(Box::new(|| Some(false))), ..Default::default() };
+        let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), services);
+        a.run("file.options", json!({"pane": "accessibility"})).unwrap();
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
+            |ui, app: &mut WordApp| {
+                let ctx = ui.ctx().clone();
+                app.logic(&ctx);
+                app.ui(ui);
+            },
+            a,
+        );
+        h.run_steps(4);
+        assert_eq!(h.state().ui.animations, Animations::System);
+        assert!(h.query_by_label("Animation effects:").is_some());
+        assert!(h.query_by_label("Your system has animation effects turned off.").is_some());
+        assert!(!h.state().animations_on());
+        h.get_by_role(egui::accesskit::Role::ComboBox).click();
+        h.run_steps(4);
+        h.get_by_label("On").click();
+        h.run_steps(4);
+        assert_eq!(h.state().ui.animations, Animations::On);
+        assert!(h.state().animations_on());
+        assert!(h.query_by_label("Your system has animation effects turned off.").is_none(), "only said while the system is followed");
+    }
+
+    /// File › Options › Advanced › Animation: the checkbox is the `ui.caretAnimation` setting,
+    /// and the section is translated.
+    #[test]
+    fn advanced_animation_turns_the_caret_animation_off_and_on() {
+        let mut a = app();
+        a.run("file.options", json!({"pane": "advanced"})).unwrap();
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
+            |ui, app: &mut WordApp| {
+                let ctx = ui.ctx().clone();
+                app.logic(&ctx);
+                app.ui(ui);
+            },
+            a,
+        );
+        h.run_steps(4);
+        assert!(h.query_by_label("Animation").is_some(), "the section is there");
+        h.get_by_label("Animate the caret (it glides and fades)").click();
+        h.run_steps(4);
+        assert!(!h.state().ui.caret_animation, "the checkbox turns it off");
+        h.get_by_label("Animate the caret (it glides and fades)").click();
+        h.run_steps(4);
+        assert!(h.state().ui.caret_animation, "and on again");
+        h.state_mut().run("ui.language", json!({"value": "es"})).unwrap();
+        h.run_steps(4);
+        assert!(h.query_by_label("Animación").is_some() && h.query_by_label("Animation").is_none());
+    }
+}
diff --git a/crates/ui-egui/src/panes.rs b/crates/ui-egui/src/panes.rs
index 2c8eff222f..c795d918ee 100644
--- a/crates/ui-egui/src/panes.rs
+++ b/crates/ui-egui/src/panes.rs
@@ -1,4 +1,6 @@
-//! Side panes: Navigation (headings, pages, search results), Clipboard, Styles, Style Inspector, Comments.
+//! Side panes: Navigation (headings, pages, search results), Clipboard, Styles, Style Inspector,
+//! Accessibility and Alt Text (see `a11y_pane`), Restrict Editing ([`crate::dialogs_review`]), Comments,
+//! and the SmartArt Text Pane.
 
 use egui::{Stroke, Ui, vec2};
 use serde_json::{Value, json};
@@ -9,6 +11,20 @@ use crate::theme::{Tokens, regular, semibold};
 
 pub fn show(app: &mut WordApp, ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
+    // SmartArt Design › Text Pane, while a SmartArt graphic WordCraft can edit is selected.
+    if app.session.view.smart_art_pane && wordcraft_engine::cmd::smart_art::selected_smart_art(&app.session).is_some() {
+        egui::Panel::left("smart_art_pane")
+            .default_size(250.0)
+            .resizable(true)
+            .frame(egui::Frame::NONE.fill(t.panel).inner_margin(10).stroke(Stroke::new(1.0, t.border)))
+            .show(ui, |ui| {
+                if header(ui, "Text Pane") {
+                    let _ = app.run("smartArt.textPane", json!({"value": false}));
+                    return;
+                }
+                crate::dialogs_smart_art::text_pane(app, ui);
+            });
+    }
     if app.session.view.nav_pane {
         egui::Panel::left("nav_pane")
             .default_size(260.0)
@@ -37,6 +53,33 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
             .frame(egui::Frame::NONE.fill(t.panel).inner_margin(10).stroke(Stroke::new(1.0, t.border)))
             .show(ui, |ui| inspector(app, ui));
     }
+    if app.session.view.accessibility_pane {
+        egui::Panel::right("accessibility_pane")
+            .default_size(280.0)
+            .resizable(true)
+            .frame(egui::Frame::NONE.fill(t.panel).inner_margin(10).stroke(Stroke::new(1.0, t.border)))
+            .show(ui, |ui| crate::a11y_pane::accessibility(app, ui));
+    }
+    if app.session.view.alt_text_pane {
+        egui::Panel::right("alt_text_pane")
+            .default_size(260.0)
+            .resizable(true)
+            .frame(egui::Frame::NONE.fill(t.panel).inner_margin(10).stroke(Stroke::new(1.0, t.border)))
+            .show(ui, |ui| crate::a11y_pane::alt_text(app, ui));
+    }
+    if app.restrict.open {
+        egui::Panel::right("restrict_pane")
+            .default_size(270.0)
+            .resizable(true)
+            .frame(egui::Frame::NONE.fill(t.panel).inner_margin(10).stroke(Stroke::new(1.0, t.border)))
+            .show(ui, |ui| {
+                if header(ui, "Restrict Editing") {
+                    app.restrict.open = false;
+                    return;
+                }
+                crate::dialogs_review::restrict_pane(app, ui);
+            });
+    }
     if app.session.view.comments_pane {
         egui::Panel::right("comments_pane")
             .default_size(290.0)
@@ -46,7 +89,7 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
     }
 }
 
-fn header(ui: &mut Ui, title: &str) -> bool {
+pub(crate) fn header(ui: &mut Ui, title: &str) -> bool {
     let mut close = false;
     ui.horizontal(|ui| {
         ui.label(egui::RichText::new(tl!(title)).font(semibold(15.0)));
@@ -566,6 +609,7 @@ fn describe(prop: &str, v: &Value) -> String {
         "spaceAfter" => "Space after",
         "lineSpacing" => "Line spacing",
         "contextualSpacing" => "Don't add space between paragraphs of the same style",
+        "mirrorIndents" => "Mirror indents",
         "keepNext" => "Keep with next",
         "keepLines" => "Keep lines together",
         "pageBreakBefore" => "Page break before",
diff --git a/crates/ui-egui/src/paste_picture.rs b/crates/ui-egui/src/paste_picture.rs
index df64f23280..73b8416a18 100644
--- a/crates/ui-egui/src/paste_picture.rs
+++ b/crates/ui-egui/src/paste_picture.rs
@@ -162,4 +162,46 @@ mod tests {
         let mut a = app_with(|| Some(ClipboardPicture::Files(vec![PathBuf::from("/tmp/notes.txt")])));
         assert_eq!(a.run("edit.paste", json!({})).unwrap_err(), "the clipboard is empty");
     }
+
+    /// The ribbon and context-menu Paste commands send no text; the system clipboard's text is
+    /// pasted, as Ctrl+V pastes it, even with a picture copied alongside (#584).
+    #[test]
+    fn paste_without_text_reads_the_system_clipboard() {
+        let services = Services {
+            clipboard_text: Some(Box::new(|| Some("outside".to_string()))),
+            clipboard_picture: Some(Box::new(|| Some(ClipboardPicture::Pixels { width: 4, height: 4, rgba: vec![200; 4 * 4 * 4] }))),
+            ..Default::default()
+        };
+        let mut a = WordApp::new(Session::new(wordcraft_doc::Document::new()), services);
+        a.run("edit.paste", json!({})).unwrap();
+        a.run("edit.pasteText", json!({})).unwrap();
+        a.run("edit.pasteMerge", json!({})).unwrap();
+        assert_eq!(pictures(&mut a), 0);
+        let focus = a.session.sel.focus.clone();
+        assert_eq!(a.session.doc.para_at(&focus).map(|p| p.text.clone()), Some("outside".repeat(3)));
+        // Paste Special offers the clipboard's text too.
+        let r = a.run("edit.pasteSpecial", json!({})).unwrap();
+        assert!(r["formats"].as_array().is_some_and(|f| f.iter().any(|x| x["id"] == "text")), "{r}");
+    }
+
+    /// Ribbon Paste after copying a picture file in a file manager inserts the picture, not its
+    /// path, as Ctrl+V does.
+    #[test]
+    fn ribbon_paste_of_copied_picture_files_inserts_them() {
+        let path = std::env::temp_dir().join(format!("wc-ribbon-paste-{}.png", std::process::id()));
+        std::fs::write(&path, png_from_rgba(4, 4, vec![200; 4 * 4 * 4]).unwrap()).unwrap();
+        let (text, file) = (path.to_string_lossy().into_owned(), path.clone());
+        let services = Services {
+            clipboard_text: Some(Box::new(move || Some(text.clone()))),
+            clipboard_picture: Some(Box::new(move || Some(ClipboardPicture::Files(vec![file.clone()])))),
+            ..Default::default()
+        };
+        let mut a = WordApp::new(Session::new(wordcraft_doc::Document::new()), services);
+        let r = a.run("edit.paste", json!({}));
+        let _ = std::fs::remove_file(&path);
+        r.unwrap();
+        assert_eq!(pictures(&mut a), 1);
+        let focus = a.session.sel.focus.clone();
+        assert_eq!(a.session.doc.para_at(&focus).map(|p| p.text.contains("wc-ribbon-paste")), Some(false));
+    }
 }
diff --git a/crates/ui-egui/src/previews.rs b/crates/ui-egui/src/previews.rs
index ffe5d81b2e..1fc566eb64 100644
--- a/crates/ui-egui/src/previews.rs
+++ b/crates/ui-egui/src/previews.rs
@@ -15,7 +15,13 @@ use crate::theme::{Tokens, regular};
 #[derive(Default)]
 pub struct Previews {
     tex: HashMap<String, TextureHandle>,
-    families: Option<Vec<String>>,
+    /// The font list, for the interface language it was made in.
+    families: Option<(&'static str, Vec<String>)>,
+    /// Lowercase English family → its name in that language (simsun → 宋体), and back.
+    local_names: HashMap<String, String>,
+    english_names: HashMap<String, String>,
+    /// The Chinese, Japanese and Korean fonts of the font list (the Asian text font box).
+    east_asian: Option<Vec<String>>,
     styles_hash: (u64, u64),
     /// Previews rendered this frame (rendering is spread over frames).
     budget: std::cell::Cell<u32>,
@@ -23,9 +29,13 @@ pub struct Previews {
 }
 
 impl Previews {
+    /// The font list: installed families, each by its name in the interface language when it has
+    /// one (宋体 for SimSun in Chinese, #505), like Word's.
     pub fn families(&mut self) -> Vec<String> {
-        if self.families.is_none() {
-            let mut f: Vec<String> = wordcraft_fonts::FontDb::global().families().into_iter().filter(|f| !f.starts_with('.')).collect();
+        let lang = crate::i18n::current().code();
+        if self.families.as_ref().is_none_or(|(l, _)| *l != lang) {
+            let db = wordcraft_fonts::FontDb::global();
+            let mut f: Vec<String> = db.families_in(lang).into_iter().filter(|f| !f.starts_with('.')).collect();
             for w in [wordcraft_doc::styles::BODY_FONT, wordcraft_doc::styles::HEADING_FONT] {
                 if !f.iter().any(|x| x == w) {
                     f.push(w.to_string());
@@ -33,9 +43,56 @@ impl Previews {
             }
             f.sort_by_key(|a| a.to_lowercase());
             f.dedup();
-            self.families = Some(f);
+            let names = db.localized_names(lang);
+            self.local_names = names.iter().map(|(e, l)| (e.to_lowercase(), l.clone())).collect();
+            self.english_names = names.into_iter().map(|(e, l)| (l, e)).collect();
+            self.families = Some((lang, f));
+            self.east_asian = None;
         }
-        self.families.clone().unwrap_or_default()
+        self.families.as_ref().map(|(_, f)| f.clone()).unwrap_or_default()
+    }
+
+    /// The Font dialog's Asian text font list: the installed Chinese, Japanese and Korean fonts,
+    /// named as in [`Previews::families`].
+    pub fn east_asian_families(&mut self) -> Vec<String> {
+        self.families();
+        if self.east_asian.is_none() {
+            let mut f: Vec<String> = wordcraft_fonts::FontDb::global()
+                .east_asian_families()
+                .into_iter()
+                .filter(|f| !f.starts_with('.'))
+                .map(|f| self.local_names.get(&f.to_lowercase()).cloned().unwrap_or(f))
+                .collect();
+            f.sort_by_key(|a| a.to_lowercase());
+            f.dedup();
+            self.east_asian = Some(f);
+        }
+        self.east_asian.clone().unwrap_or_default()
+    }
+
+    /// The name the font box shows for the document's font `family`: its name in the interface
+    /// language when the font has one.
+    pub fn font_shown(&mut self, family: &str) -> String {
+        self.families();
+        self.local_names.get(&family.to_lowercase()).cloned().unwrap_or_else(|| family.to_string())
+    }
+
+    /// The family name a font chosen in the font box is stored as: the English name for a font
+    /// listed by its localized name (宋体 → SimSun), so the document reads the same anywhere.
+    pub fn font_stored(&mut self, shown: &str) -> String {
+        self.families();
+        self.english_names.get(shown).cloned().unwrap_or_else(|| shown.to_string())
+    }
+
+    /// Fonts were added or removed: list the families again and redraw the entries of
+    /// `families` (an entry drawn before its font was added shows the fallback face).
+    pub fn fonts_changed(&mut self, ctx: &egui::Context, families: impl Iterator<Item = String>) {
+        self.families = None;
+        ctx.data_mut(|d| {
+            for f in families {
+                d.remove::<TextureHandle>(egui::Id::new(format!("font:{f}")));
+            }
+        });
     }
 
     /// A closure drawing a font-menu entry in its own face.
@@ -64,7 +121,7 @@ impl Previews {
                     return None;
                 }
                 let ppp = ui.ctx().pixels_per_point();
-                let img = snippet(
+                let mut img = snippet(
                     &Document::new(),
                     Paragraph::with_text(name, CharProps { font: Some(name.to_string()), size: Some(13.0), ..Default::default() }),
                     240.0,
@@ -72,6 +129,7 @@ impl Previews {
                     ppp,
                     2.0,
                 )?;
+                ink_mask(&mut img);
                 let h = ui.ctx().load_texture(&key, img, egui::TextureOptions::LINEAR);
                 ui.ctx().data_mut(|d| d.insert_temp(egui::Id::new(&key), h.clone()));
                 Some(h)
@@ -83,7 +141,7 @@ impl Previews {
                         h.id(),
                         Rect::from_min_size(pos2(r.min.x + 6.0, r.center().y - sz.y / 2.0), sz),
                         Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)),
-                        egui::Color32::WHITE,
+                        t.text,
                     );
                 }
                 None => {
@@ -183,6 +241,19 @@ fn math_image(nodes: &wordcraft_doc::math::Arg, display: bool, pt: f32, w: f32,
     Some(egui::ColorImage::from_rgba_unmultiplied([img.width as usize, img.height as usize], &px))
 }
 
+/// Turn a snippet rendered black on white paper into an ink mask: white whose alpha is the ink's
+/// coverage, on a transparent background. Painted with the theme's text colour as the tint, a font
+/// menu entry then reads like the rest of the menu in light and dark mode instead of sitting on a
+/// white strip (#535).
+pub fn ink_mask(img: &mut egui::ColorImage) {
+    for p in &mut img.pixels {
+        let [r, g, b, a] = p.to_srgba_unmultiplied();
+        let lum = (u32::from(r) * 299 + u32::from(g) * 587 + u32::from(b) * 114) / 1000;
+        let ink = 255u32.saturating_sub(lum.min(255)) * u32::from(a) / 255;
+        *p = egui::Color32::from_white_alpha(u8::try_from(ink).unwrap_or(u8::MAX));
+    }
+}
+
 /// Lay out `para` (with `base`'s styles) in a `w`×`h` pt box and rasterise it.
 pub fn snippet(base: &Document, para: Paragraph, w: f32, h: f32, ppp: f32, margin: f32) -> Option<egui::ColorImage> {
     snippet_blocks(base, vec![Block::Para(para)], w, h, ppp, margin, None)
@@ -314,6 +385,17 @@ pub fn style_gallery(app: &mut WordApp, ui: &mut Ui, state: &Value) {
         let galley = ui.painter().layout_job(job);
         let label_pos = pos2(r.center().x - galley.size().x / 2.0, r.max.y - 9.0 - galley.size().y / 2.0);
         ui.painter().with_clip_rect(r).galley(label_pos, galley, t.text);
+        // Right-click a tile: the same style actions as the Styles pane.
+        resp.context_menu(|ui| {
+            if ui.button(tl!("Update to Match Selection")).clicked() {
+                let _ = app.run("styles.updateToMatch", json!({"style": id}));
+                ui.close();
+            }
+            if ui.button(tl!("Modify…")).clicked() {
+                app.dialog = crate::dialogs::Dialog::modify_style(app, id);
+                ui.close();
+            }
+        });
         if resp.on_hover_text(name).clicked() {
             let _ = app.run("para.style", json!({"style": id}));
         }
@@ -339,12 +421,19 @@ pub fn style_gallery(app: &mut WordApp, ui: &mut Ui, state: &Value) {
     }
 }
 
+/// Style sets shown in the Design tab's gallery, in order.
+const STYLE_SETS: [&str; 7] = ["default", "basic", "lines", "shaded", "casual", "centered", "minimalist"];
+/// Width of one gallery thumbnail, points.
+const STYLE_SET_W: f32 = 56.0;
+/// Width the whole gallery takes with the ribbon's 1 pt item spacing.
+pub const STYLE_SET_GALLERY_W: f32 = STYLE_SETS.len() as f32 * (STYLE_SET_W + 1.0) - 1.0;
+
 /// Design tab: style set tiles.
 pub fn style_set_gallery(app: &mut WordApp, ui: &mut Ui) {
     let t = Tokens::get(ui.ctx());
     let ppp = ui.ctx().pixels_per_point();
-    for name in ["default", "basic", "lines", "shaded", "casual", "centered", "minimalist"] {
-        let (r, resp) = ui.allocate_exact_size(vec2(56.0, crate::widgets::CONTENT_H), Sense::click());
+    for name in STYLE_SETS {
+        let (r, resp) = ui.allocate_exact_size(vec2(STYLE_SET_W, crate::widgets::CONTENT_H), Sense::click());
         if resp.hovered() {
             ui.painter().rect_filled(r, 3.0, t.hover);
         }
@@ -443,4 +532,48 @@ mod tests {
         rx.recv_timeout(std::time::Duration::from_secs(30)).expect("font menu preview rendering hung or failed");
         worker.join().unwrap();
     }
+
+    #[test]
+    fn ink_mask_keeps_the_ink_and_drops_the_paper() {
+        let mut img = egui::ColorImage::new([3, 1], vec![egui::Color32::WHITE, egui::Color32::BLACK, egui::Color32::from_gray(128)]);
+        ink_mask(&mut img);
+        assert_eq!(img.pixels[0].a(), 0, "paper becomes transparent");
+        assert_eq!(img.pixels[1], egui::Color32::from_white_alpha(255), "full ink stays opaque");
+        assert_eq!(img.pixels[2].a(), 127, "antialiased ink keeps its coverage");
+    }
+
+    /// #535: font menu entries drew on a white strip in dark mode. They are now tinted with the
+    /// theme's text colour and draw no background of their own.
+    #[test]
+    fn font_menu_entries_take_the_theme_text_colour() {
+        for theme in [egui::Theme::Dark, egui::Theme::Light] {
+            let ctx = egui::Context::default();
+            crate::theme::apply(&ctx, crate::theme::Appearance::System);
+            ctx.set_theme(theme);
+            let preview = Previews::default().font_preview_fn();
+            let mut out = None;
+            for time in [1.0, 2.0] {
+                let input = egui::RawInput { time: Some(time), ..Default::default() };
+                let mut o = ctx.run_ui(input, |ui| {
+                    preview(ui, "Source Sans 3");
+                });
+                o.textures_delta.clear();
+                out = Some(o);
+            }
+            let want = if theme == egui::Theme::Dark { Tokens::dark().text } else { Tokens::light().text };
+            let shapes = out.map(|o| o.shapes).unwrap_or_default();
+            let mut images = 0;
+            for s in &shapes {
+                match &s.shape {
+                    egui::Shape::Mesh(m) if m.texture_id != egui::TextureId::default() => {
+                        images += 1;
+                        assert!(m.vertices.iter().all(|v| v.color == want), "{theme:?}: the entry is not tinted with the text colour");
+                    }
+                    egui::Shape::Rect(r) => panic!("{theme:?}: an idle entry paints no background, got {:?}", r.fill),
+                    _ => {}
+                }
+            }
+            assert_eq!(images, 1, "{theme:?}: the entry draws its rendered name");
+        }
+    }
 }
diff --git a/crates/ui-egui/src/print_page.rs b/crates/ui-egui/src/print_page.rs
new file mode 100644
index 0000000000..560dbe81b6
--- /dev/null
+++ b/crates/ui-egui/src/print_page.rs
@@ -0,0 +1,238 @@
+//! File › Print (#641): the print settings and a preview of the pages.
+//!
+//! WordCraft prints through a PDF that the host opens in the system's print flow, so the settings
+//! here are the ones that shape that PDF: which pages, odd/even, copies and collation. They go to
+//! `ui.print` / `file.printPdf` as params (see `wordcraft_engine::print`). The printer, two-sided
+//! printing and pages per sheet are chosen in the system print dialog that opens next.
+
+use std::sync::Arc;
+
+use egui::{Rect, Sense, Stroke, TextureHandle, Ui, pos2, vec2};
+use serde_json::{Value, json};
+use wordcraft_layout::DocLayout;
+
+use crate::theme::{Tokens, medium, regular};
+use crate::{WordApp, icons};
+
+/// The Print page's settings. Not saved with the document or the UI state.
+#[derive(Clone, Debug, PartialEq)]
+pub struct PrintSettings {
+    /// `all`, `current`, `selection` or `custom`.
+    pub range: String,
+    /// The custom range text, like `1-3, 5`.
+    pub pages: String,
+    /// `all`, `odd` or `even`.
+    pub parity: String,
+    pub copies: u32,
+    pub collate: bool,
+    /// The page shown in the preview (0-based).
+    pub preview: usize,
+}
+
+impl Default for PrintSettings {
+    fn default() -> Self {
+        PrintSettings { range: "all".into(), pages: String::new(), parity: "all".into(), copies: 1, collate: true, preview: 0 }
+    }
+}
+
+impl PrintSettings {
+    /// The params of `ui.print` and `file.printPdf` for these settings.
+    pub fn params(&self) -> Value {
+        let mut v = json!({"range": self.range, "parity": self.parity, "copies": self.copies, "collate": self.collate});
+        if self.range == "custom" {
+            v["pages"] = json!(self.pages);
+        }
+        v
+    }
+}
+
+const RANGES: [(&str, &str); 4] = [("all", "All pages"), ("current", "Current page"), ("selection", "Selected pages"), ("custom", "Custom range")];
+const PARITIES: [(&str, &str); 3] = [("all", "All pages in the range"), ("odd", "Odd pages only"), ("even", "Even pages only")];
+
+/// A choice list over `(id, label)` pairs; true when the choice changed.
+fn choice(ui: &mut Ui, salt: &str, current: &mut String, items: &[(&str, &str)]) -> bool {
+    let shown = items.iter().find(|(id, _)| *id == current.as_str()).map_or("", |(_, l)| *l);
+    let mut changed = false;
+    egui::ComboBox::from_id_salt(salt).width(260.0).selected_text(tl!(shown)).show_ui(ui, |ui| {
+        for (id, label) in items {
+            if ui.selectable_label(current == id, tl!(label)).clicked() && current != id {
+                *current = (*id).to_string();
+                changed = true;
+            }
+        }
+    });
+    changed
+}
+
+/// The output layout, kept while the document is unchanged (laying out every frame would be slow).
+fn layout_of(app: &WordApp, ctx: &egui::Context) -> Arc<DocLayout> {
+    let id = egui::Id::new("print_page_layout");
+    let rev = app.session.rev();
+    if let Some((r, l)) = ctx.data(|d| d.get_temp::<(u64, Arc<DocLayout>)>(id))
+        && r == rev
+    {
+        return l;
+    }
+    let l = app.session.export_layout();
+    ctx.data_mut(|d| d.insert_temp(id, (rev, l.clone())));
+    l
+}
+
+/// The texture of one page, re-rendered only when the document, page or size changes.
+fn page_texture(app: &WordApp, ctx: &egui::Context, lay: &DocLayout, page: usize, width: f32) -> Option<TextureHandle> {
+    let id = egui::Id::new("print_page_texture");
+    let key = (app.session.rev(), page, width as u32, (ctx.pixels_per_point() * 100.0) as u32);
+    if let Some((k, t)) = ctx.data(|d| d.get_temp::<((u64, usize, u32, u32), TextureHandle)>(id))
+        && k == key
+    {
+        return Some(t);
+    }
+    let pg = lay.pages.get(page)?;
+    let scale = (width / pg.w.max(1.0) * ctx.pixels_per_point()).clamp(0.05, 4.0);
+    let img = wordcraft_render::render_page(&app.session.doc, pg, scale, &Default::default());
+    let color = egui::ColorImage::from_rgba_unmultiplied([img.width as usize, img.height as usize], &img.to_straight());
+    let tex = ctx.load_texture("print_page_preview", color, egui::TextureOptions::LINEAR);
+    ctx.data_mut(|d| d.insert_temp(id, (key, tex.clone())));
+    Some(tex)
+}
+
+/// The Print page: settings on the left, the preview on the right.
+pub fn show(app: &mut WordApp, ui: &mut Ui) {
+    let t = Tokens::get(ui.ctx());
+    let ctx = ui.ctx().clone();
+    let lay = layout_of(app, &ctx);
+    let total = lay.pages.len();
+    let current = app.session.current_pages(&lay);
+    app.ui.print.preview = app.ui.print.preview.min(total.saturating_sub(1));
+
+    ui.horizontal_top(|ui| {
+        ui.vertical(|ui| {
+            ui.set_width(380.0);
+            ui.spacing_mut().item_spacing.y = 8.0;
+            let hook = app.services.print.is_some();
+            if hook {
+                ui.label(tl!("Send the document straight to the system print dialog, or save a copy in another format below."));
+                ui.label(
+                    egui::RichText::new(tl!("The printer, two-sided printing and pages per sheet are chosen in that dialog.")).color(t.text_dim),
+                );
+            } else {
+                ui.label(tl!("Save a copy in another format. Printing goes through a PDF you can print from any viewer."));
+            }
+            ui.add_space(4.0);
+            if hook && ui.add(egui::Button::new(egui::RichText::new(tl!("Print")).font(medium(13.5))).min_size(vec2(320.0, 34.0))).clicked() {
+                let params = app.ui.print.params();
+                let _ = app.run("ui.print", params);
+            }
+            if ui
+                .add(egui::Button::new(egui::RichText::new(tl!("Save these pages as PDF…")).font(medium(13.5))).min_size(vec2(320.0, 34.0)))
+                .clicked()
+            {
+                app.print_pdf_dialog();
+            }
+            ui.add_space(6.0);
+
+            ui.label(egui::RichText::new(tl!("Copies")).font(medium(13.0)));
+            ui.horizontal(|ui| {
+                let mut n = app.ui.print.copies;
+                ui.add(egui::DragValue::new(&mut n).range(1..=wordcraft_engine::print::MAX_COPIES).speed(0.2));
+                app.ui.print.copies = n.clamp(1, wordcraft_engine::print::MAX_COPIES);
+                if app.ui.print.copies > 1 {
+                    ui.checkbox(&mut app.ui.print.collate, tl!("Collate copies"));
+                }
+            });
+
+            ui.label(egui::RichText::new(tl!("Pages")).font(medium(13.0)));
+            if choice(ui, "print_range", &mut app.ui.print.range, &RANGES) {
+                // Show the first page that will print.
+                app.ui.print.preview = if app.ui.print.range == "all" { 0 } else { current.0.min(total.saturating_sub(1)) };
+            }
+            if app.ui.print.range == "custom" {
+                ui.add(
+                    egui::TextEdit::singleline(&mut app.ui.print.pages)
+                        .hint_text(tl!("Pages like 1-3, 5"))
+                        .desired_width(260.0)
+                        .char_limit(wordcraft_engine::print::MAX_SPEC_CHARS),
+                );
+            }
+            choice(ui, "print_parity", &mut app.ui.print.parity, &PARITIES);
+
+            match wordcraft_engine::print::plan(&app.ui.print.params(), total, current) {
+                Ok(plan) => {
+                    let msg = crate::i18n::fmt(
+                        tl!("{count} of {total} pages will print"),
+                        &[("count", &plan.chosen.to_string()), ("total", &total.to_string())],
+                    );
+                    ui.label(egui::RichText::new(msg).color(t.text_dim));
+                }
+                Err(e) => {
+                    ui.label(egui::RichText::new(e.to_string()).color(t.red));
+                }
+            }
+            ui.add_space(8.0);
+            ui.separator();
+            ui.add_space(4.0);
+            if hook {
+                ui.label(tl!("Or save a copy in another format:"));
+            }
+            export_formats(app, ui);
+        });
+        ui.add_space(24.0);
+        ui.vertical(|ui| preview(app, ui, &lay, total));
+    });
+}
+
+/// The preview: one page with Previous/Next.
+fn preview(app: &mut WordApp, ui: &mut Ui, lay: &DocLayout, total: usize) {
+    let t = Tokens::get(ui.ctx());
+    let ctx = ui.ctx().clone();
+    let width = 340.0;
+    let page = app.ui.print.preview;
+    let aspect = lay.pages.get(page).map_or(11.0 / 8.5, |p| p.h.max(1.0) / p.w.max(1.0)).clamp(0.2, 5.0);
+    let (r, _) = ui.allocate_exact_size(vec2(width, width * aspect), Sense::hover());
+    ui.painter().rect_filled(r.translate(vec2(2.0, 3.0)), 0.0, t.page_shadow);
+    ui.painter().rect(r, 0.0, egui::Color32::WHITE, Stroke::new(1.0, t.border_strong), egui::StrokeKind::Inside);
+    if let Some(tex) = page_texture(app, &ctx, lay, page, width) {
+        ui.painter().image(tex.id(), r, Rect::from_min_max(pos2(0.0, 0.0), pos2(1.0, 1.0)), egui::Color32::WHITE);
+    }
+    ui.add_space(6.0);
+    ui.horizontal(|ui| {
+        let nav = |ui: &mut Ui, icon: &str, tip: &str, enabled: bool| {
+            let (r, resp) = ui.allocate_exact_size(vec2(26.0, 26.0), Sense::click());
+            let col = if enabled { t.icon } else { t.text_disabled };
+            if enabled && resp.hovered() {
+                ui.painter().rect_filled(r, 3.0, t.hover);
+            }
+            icons::paint(ui.painter(), r.shrink(4.0), icon, col, col);
+            enabled && resp.on_hover_text(tip).clicked()
+        };
+        if nav(ui, "chevronLeft", tl!("Previous Page"), page > 0) {
+            app.ui.print.preview = page - 1;
+        }
+        let label = crate::i18n::fmt(tl!("Page {page} of {pages}"), &[("page", &(page + 1).to_string()), ("pages", &total.to_string())]);
+        ui.label(egui::RichText::new(label).font(regular(13.0)));
+        if nav(ui, "chevronRight", tl!("Next Page"), page + 1 < total) {
+            app.ui.print.preview = page + 1;
+        }
+    });
+}
+
+/// The "save a copy" formats (File › Export, and below the settings on the Print page).
+pub fn export_formats(app: &mut WordApp, ui: &mut Ui) {
+    for (label, ext) in [
+        ("PDF document (*.pdf)", "pdf"),
+        ("Word document (*.docx)", "docx"),
+        ("Word XML Document (*.xml)", "xml"),
+        ("OpenDocument Text (*.odt)", "odt"),
+        ("Rich Text Format (*.rtf)", "rtf"),
+        ("Web page (*.html)", "html"),
+        ("Markdown (*.md)", "md"),
+        ("LaTeX (*.tex)", "tex"),
+        ("Plain text (*.txt)", "txt"),
+        ("Page image (*.png)", "png"),
+    ] {
+        if ui.add(egui::Button::new(egui::RichText::new(tl!(label)).font(medium(13.5))).min_size(vec2(320.0, 34.0))).clicked() {
+            app.export_dialog(ext);
+        }
+        ui.add_space(4.0);
+    }
+}
diff --git a/crates/ui-egui/src/ribbon.rs b/crates/ui-egui/src/ribbon.rs
index aea4fe5bae..b374376bd2 100644
--- a/crates/ui-egui/src/ribbon.rs
+++ b/crates/ui-egui/src/ribbon.rs
@@ -3,11 +3,12 @@
 use egui::{Align2, Rect, Sense, Stroke, Ui, pos2, vec2};
 use serde_json::{Value, json};
 
+use crate::colors::{Remember, Target};
 use crate::theme::{Tokens, medium, regular, semibold};
-use crate::widgets::{CONTENT_H, LABEL_H, big, big_toggle, color_grid, combo, font_combo, group, menu_button, small, split};
+use crate::widgets::{CONTENT_H, LABEL_H, big, big_toggle, combo, font_combo, group, menu_button, small, split};
 use crate::{WordApp, icons};
 
-pub const TABS: [&str; 12] = wordcraft_engine::ribbon::TABS;
+pub const TABS: [&str; 13] = wordcraft_engine::ribbon::TABS;
 
 /// True when the caret/selection touches a picture (#147).
 pub fn has_picture_selected(s: &wordcraft_engine::Session) -> bool {
@@ -22,6 +23,16 @@ pub fn has_shape_selected(s: &wordcraft_engine::Session) -> bool {
     }
 }
 
+/// Whether the selection is a SmartArt graphic WordCraft can edit (so SmartArt Design is shown).
+pub fn has_smart_art_selected(s: &wordcraft_engine::Session) -> bool {
+    wordcraft_engine::cmd::smart_art::selected_smart_art(s).is_some()
+}
+
+/// Whether the selection is a chart WordCraft can edit (so Chart Design is shown).
+pub fn has_chart_selected(s: &wordcraft_engine::Session) -> bool {
+    wordcraft_engine::cmd::chart::selected_chart(s).is_some()
+}
+
 /// Contextual tabs for the current selection (pure, tested).
 pub fn contextual_tabs(s: &wordcraft_engine::Session) -> Vec<&'static str> {
     let mut tabs = Vec::new();
@@ -35,10 +46,20 @@ pub fn contextual_tabs(s: &wordcraft_engine::Session) -> Vec<&'static str> {
     if has_shape_selected(s) {
         tabs.push("Shape Format");
     }
+    if has_smart_art_selected(s) {
+        tabs.push("SmartArt Design");
+    }
+    if has_chart_selected(s) {
+        tabs.push("Chart Design");
+    }
     // Editing an equation.
     if s.math.is_some() {
         tabs.push("Equation");
     }
+    // Outline view (drawn first, next to File, as Word does).
+    if s.view.mode == wordcraft_layout::ViewMode::Outline {
+        tabs.push("Outlining");
+    }
     tabs
 }
 
@@ -65,14 +86,27 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
     {
         app.ui.tab = prev;
     }
+    // Outline view brings up the Outlining tab; closing it goes back.
+    if app.session.view.mode == wordcraft_layout::ViewMode::Outline {
+        if app.outline_prev_tab.is_none() {
+            app.outline_prev_tab = Some(app.ui.tab.clone());
+            app.ui.tab = "Outlining".into();
+        }
+    } else if let Some(prev) = app.outline_prev_tab.take()
+        && app.ui.tab == "Outlining"
+    {
+        app.ui.tab = prev;
+    }
     // The tabs shown: File, the user's tabs in their order (Customize Ribbon, #379), then the
-    // contextual ones. A contextual tab (Table, Picture Format) may be stored while the selection
-    // moved away, and a tab may have been hidden.
+    // contextual ones (the Outlining tab right after File). A contextual tab (Table, Picture
+    // Format) may be stored while the selection moved away, and a tab may have been hidden.
     let user_tabs = app.session.ribbon.tabs().into_owned();
     let mut tabs: Vec<(String, bool)> = vec![("File".to_string(), false)];
     tabs.extend(user_tabs.iter().filter(|e| !e.hidden).map(|e| (e.name.clone(), e.custom)));
     for ct in contextual_tabs(&app.session) {
-        if !tabs.iter().any(|(n, _)| n == ct) {
+        if ct == "Outlining" {
+            tabs.insert(1.min(tabs.len()), (ct.to_string(), false));
+        } else if !tabs.iter().any(|(n, _)| n == ct) {
             tabs.push((ct.to_string(), false));
         }
     }
@@ -129,10 +163,10 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
                         ui.painter(),
                         Rect::from_center_size(pos2(r.min.x + 14.0, r.center().y), vec2(14.0, 14.0)),
                         "share",
-                        egui::Color32::WHITE,
-                        egui::Color32::WHITE,
+                        t.on_accent,
+                        t.on_accent,
                     );
-                    ui.painter().text(pos2(r.min.x + 26.0, r.center().y), Align2::LEFT_CENTER, share, medium(12.0), egui::Color32::WHITE);
+                    ui.painter().text(pos2(r.min.x + 26.0, r.center().y), Align2::LEFT_CENTER, share, medium(12.0), t.on_accent);
                     if resp.on_hover_text(tl!("Export a copy to share (PDF, Word document)")).clicked() {
                         let _ = app.run("ui.backstage", json!({"value": true, "page": "export"}));
                     }
@@ -194,6 +228,7 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
                         "Mailings" => mailings(app, ui),
                         "Review" => review(app, ui),
                         "View" => view(app, ui),
+                        "Developer" => developer(app, ui),
                         "Zotero" => zotero(app, ui),
                         "Help" => help(app, ui),
                         "Table Design" => table_design(app, ui),
@@ -201,6 +236,9 @@ pub fn show(app: &mut WordApp, ui: &mut Ui) {
                         "Equation" if app.session.math.is_some() => crate::equation_tab::show(app, ui),
                         "Picture Format" => picture_format(app, ui),
                         "Shape Format" => shape_format(app, ui),
+                        "SmartArt Design" => smart_art_design(app, ui),
+                        "Outlining" => outlining(app, ui),
+                        "Chart Design" => chart_design(app, ui),
                         _ => home(app, ui),
                     }
                     if let Some(e) = entry {
@@ -289,7 +327,7 @@ fn stack(ui: &mut Ui, add: impl FnOnce(&mut Ui)) {
     });
 }
 
-fn mi(ui: &mut Ui, app: &mut WordApp, label: &str, id: &str, params: Value) {
+pub(crate) fn mi(ui: &mut Ui, app: &mut WordApp, label: &str, id: &str, params: Value) {
     mi_text(ui, app, tl!(label), id, params);
 }
 
@@ -357,6 +395,37 @@ fn mi_check(ui: &mut Ui, app: &mut WordApp, label: &str, checked: bool, id: &str
     }
 }
 
+/// Word's text wrapping styles in menu order: label, model value, `arrange.wrap` parameter.
+pub(crate) const WRAP_STYLES: [(&str, wordcraft_doc::para::Wrap, &str); 7] = {
+    use wordcraft_doc::para::Wrap;
+    [
+        ("In Line with Text", Wrap::Inline, "inline"),
+        ("Square", Wrap::Square, "square"),
+        ("Tight", Wrap::Tight, "tight"),
+        ("Through", Wrap::Through, "through"),
+        ("Top and Bottom", Wrap::TopAndBottom, "topAndBottom"),
+        ("Behind Text", Wrap::BehindText, "behindText"),
+        ("In Front of Text", Wrap::InFrontOfText, "inFrontOfText"),
+    ]
+};
+
+/// The Wrap Text menu for the selected picture, shape or text box: the seven styles (the
+/// current one checked), then Move with Text / Fix Position on Page for a floating one. The
+/// canvas context menu shows it; the ribbon's Wrap Text button can share it.
+pub(crate) fn wrap_text_items(ui: &mut Ui, app: &mut WordApp) {
+    use wordcraft_engine::cmd::objects::{moves_with_text, selected};
+    let state = selected(&app.session).and_then(|(_, o)| o.frame().map(|(_, _, f)| (f.wrap, moves_with_text(f))));
+    let wrap = state.map(|(w, _)| w);
+    for (label, w, v) in WRAP_STYLES {
+        mi_check(ui, app, label, wrap == Some(w), "arrange.wrap", json!({"wrap": v}));
+    }
+    ui.separator();
+    // An inline object is neither: it's part of the text.
+    let with_text = state.filter(|(w, _)| *w != wordcraft_doc::para::Wrap::Inline).map(|(_, m)| m);
+    mi_check(ui, app, "Move with Text", with_text == Some(true), "arrange.moveWithText", json!({"value": true}));
+    mi_check(ui, app, "Fix Position on Page", with_text == Some(false), "arrange.moveWithText", json!({"value": false}));
+}
+
 fn home(app: &mut WordApp, ui: &mut Ui) {
     let st = app.session.run("format.state", &json!({})).unwrap_or_default();
     let flag = |k: &str| st.get(k).and_then(Value::as_bool).unwrap_or(false);
@@ -381,10 +450,16 @@ fn home(app: &mut WordApp, ui: &mut Ui) {
         stack(ui, |ui| {
             crate::widgets::row(ui, |ui| {
                 let font = st.get("font").and_then(Value::as_str).unwrap_or("").to_string();
+                let font = app.previews.font_shown(&font);
                 let fams = app.previews.families();
                 let prev = app.previews.font_preview_fn();
                 if let Some(f) = font_combo(ui, "font", 150.0, &font, &fams, Some(&*prev)) {
-                    let _ = app.run("format.font", json!({"name": f}));
+                    let _ = if f == crate::widgets::ADD_FONT {
+                        app.run("font.add", json!({}))
+                    } else {
+                        let f = app.previews.font_stored(&f);
+                        app.run("format.font", json!({"name": f}))
+                    };
                 }
                 let size = st
                     .get("size")
@@ -436,6 +511,14 @@ fn home(app: &mut WordApp, ui: &mut Ui) {
                 small(ui, app, "enclose", None, "Enclose Characters", "format.enclose", json!({}), false);
                 ui.add_space(4.0);
                 menu_button(ui, app, "effects", None, "Text Effects and Typography", false, |ui, app| {
+                    let theme = app.session.doc.settings.theme_colors.clone();
+                    crate::wordart_menus::style_gallery(ui, app, "format.textEffects");
+                    ui.separator();
+                    ui.menu_button(tl!("Text Fill"), |ui| crate::wordart_menus::fill_menu(ui, app, &theme));
+                    let outline = crate::wordart_menus::current_outline(app);
+                    ui.menu_button(tl!("Text Outline"), |ui| crate::wordart_menus::outline_menu(ui, app, &theme, outline));
+                    crate::wordart_menus::effects_menu(ui, app, &theme, false);
+                    ui.separator();
                     mi(ui, app, "Outline", "format.outline", json!({}));
                     mi(ui, app, "Shadow", "format.shadow", json!({}));
                     mi(ui, app, "Small Caps", "format.smallCaps", json!({}));
@@ -467,11 +550,7 @@ fn home(app: &mut WordApp, ui: &mut Ui) {
                 split(ui, app, "fontcolor", "Font Color", "format.color", json!({"color": fc}), false, sw, |ui, app| {
                     mi(ui, app, "Automatic", "format.color", json!({"color": "auto"}));
                     let theme = app.session.doc.settings.theme_colors.clone();
-                    if let Some(hex) = color_grid(ui, &theme) {
-                        app.canvas.last_font_color = hex.clone();
-                        let _ = app.run("format.color", json!({"color": hex}));
-                        ui.close();
-                    }
+                    crate::colors::menu(ui, app, &theme, Target::cmd("format.color").remember(Remember::FontColor));
                 });
             });
         });
@@ -560,11 +639,7 @@ fn home(app: &mut WordApp, ui: &mut Ui) {
                 split(ui, app, "shading", "Shading", "para.shading", json!({"color": app.canvas.last_shading.clone()}), false, None, |ui, app| {
                     mi(ui, app, "No Color", "para.shading", json!({"color": null}));
                     let theme = app.session.doc.settings.theme_colors.clone();
-                    if let Some(hex) = color_grid(ui, &theme) {
-                        app.canvas.last_shading = hex.clone();
-                        let _ = app.run("para.shading", json!({"color": hex}));
-                        ui.close();
-                    }
+                    crate::colors::menu(ui, app, &theme, Target::cmd("para.shading").remember(Remember::Shading));
                 });
                 split(ui, app, "borders", "Borders", "para.borders", json!({"kind": "bottom"}), false, None, |ui, app| {
                     for (l, k) in [
@@ -655,6 +730,17 @@ fn insert(app: &mut WordApp, ui: &mut Ui) {
             }
             ui.separator();
             mi(ui, app, "New Drawing Canvas", "insert.canvas", json!({}));
+            // Connectors: glue their ends to shapes by dragging them (shape.connect).
+            for (l, k, arrow) in [
+                ("Straight Connector", "straightConnector", "none"),
+                ("Straight Arrow Connector", "straightConnector", "end"),
+                ("Elbow Connector", "elbowConnector", "none"),
+                ("Elbow Arrow Connector", "elbowConnector", "end"),
+                ("Curved Connector", "curvedConnector", "none"),
+                ("Curved Arrow Connector", "curvedConnector", "end"),
+            ] {
+                mi(ui, app, l, "insert.shape", json!({"kind": k, "arrow": arrow}));
+            }
         });
         stack(ui, |ui| {
             small(ui, app, "icons", Some("Icons"), "Icons", "insert.icon", json!({}), false);
@@ -710,7 +796,9 @@ fn insert(app: &mut WordApp, ui: &mut Ui) {
                 }
                 mi(ui, app, "Field…", "ui.dialog", json!({"name": "field"}));
             });
-            small(ui, app, "wordArt", Some("WordArt"), "WordArt", "insert.wordArt", json!({}), false);
+            menu_button(ui, app, "wordArt", Some("WordArt"), "WordArt", false, |ui, app| {
+                crate::wordart_menus::style_gallery(ui, app, "insert.wordArt")
+            });
             small(ui, app, "dropCap", Some("Drop Cap"), "Drop Cap", "insert.dropCap", json!({}), false);
         });
         stack(ui, |ui| {
@@ -757,53 +845,140 @@ fn insert(app: &mut WordApp, ui: &mut Ui) {
 
 fn draw(app: &mut WordApp, ui: &mut Ui) {
     use wordcraft_doc::freeform::InkTool;
-    use wordcraft_engine::cmd::draw::DrawMode;
+    use wordcraft_engine::cmd::draw::{DrawMode, lasso_selection};
     let mode = app.session.view.draw.mode;
     // The pen the colour and thickness menus change: the one in use, else the pen.
     let tool = mode.pen().unwrap_or(InkTool::Pen);
-    let pen_id = |t: InkTool| match t {
-        InkTool::Pen => "draw.pen",
-        InkTool::Pencil => "draw.pencil",
-        InkTool::Highlighter => "draw.highlighter",
-    };
+    let set = app.session.view.draw.settings(tool);
+    // The gallery pen in use, if any: changing the colour or thickness changes it too.
+    let custom =
+        app.session.view.draw.pens.iter().position(|p| mode == DrawMode::Pen(p.kind) && p.color == set.color && (p.width - set.width).abs() < 0.01);
+    let lasso_on = lasso_selection(&app.session).is_some();
     group(ui, "Drawing Tools", None, app, |ui, app| {
         big_toggle(ui, app, "select", "Select", "draw.select", mode == DrawMode::Select);
-        big(ui, app, "lasso", "Lasso", "draw.lasso", json!({}), false);
+        big_toggle(ui, app, "lasso", "Lasso", "draw.lasso", mode == DrawMode::Lasso);
         big_toggle(ui, app, "eraser", "Eraser", "draw.eraser", mode == DrawMode::Eraser);
-        big_toggle(ui, app, "pen", "Pen", "draw.pen", mode == DrawMode::Pen(InkTool::Pen));
-        big_toggle(ui, app, "pencil", "Pencil", "draw.pencil", mode == DrawMode::Pen(InkTool::Pencil));
-        big_toggle(ui, app, "highlight", "Highlighter", "draw.highlighter", mode == DrawMode::Pen(InkTool::Highlighter));
-        let set = app.session.view.draw.settings(tool);
+        big_toggle(ui, app, "pen", "Pen", "draw.pen", mode == DrawMode::Pen(InkTool::Pen) && custom.is_none());
+        big_toggle(ui, app, "pencil", "Pencil", "draw.pencil", mode == DrawMode::Pen(InkTool::Pencil) && custom.is_none());
+        big_toggle(ui, app, "highlight", "Highlighter", "draw.highlighter", mode == DrawMode::Pen(InkTool::Highlighter) && custom.is_none());
+        // Pens added with Add Pen; right-click one to remove it.
+        let pens = app.session.view.draw.pens.clone();
+        for (i, pen) in pens.iter().enumerate() {
+            gallery_pen(ui, app, i, *pen, custom == Some(i));
+        }
+        menu_button(ui, app, "addPen", Some("Add\nPen"), "Add Pen", true, |ui, app| {
+            for (label, kind) in [("Pen", InkTool::Pen), ("Pencil", InkTool::Pencil), ("Highlighter", InkTool::Highlighter)] {
+                // A new pen starts as that kind's current colour and thickness.
+                let cur = app.session.view.draw.settings(kind);
+                mi(ui, app, label, "draw.addPen", json!({"kind": kind.name(), "color": cur.color.hex(), "width": cur.width}));
+            }
+        });
         stack(ui, |ui| {
             let sw = Some(crate::theme::c32(set.color));
-            split(ui, app, "fontcolor", "Color", pen_id(tool), json!({}), false, sw, |ui, app| {
+            split(ui, app, "fontcolor", "Color", pen_command(tool), json!({}), false, sw, |ui, app| {
                 let theme = app.session.doc.settings.theme_colors.clone();
-                if let Some(hex) = color_grid(ui, &theme) {
-                    let _ = app.run(pen_id(tool), json!({"color": hex}));
-                    ui.close();
+                // With ink lasso-selected the colour goes to the selection, else to the pen.
+                let cmd = if lasso_on { "draw.lassoColor" } else { pen_command(tool) };
+                crate::colors::menu(ui, app, &theme, Target::cmd(cmd));
+                if !lasso_on {
+                    update_gallery_pen(app, custom, tool);
                 }
             });
             menu_button(ui, app, "thickness", None, "Thickness", false, |ui, app| {
                 let widths: &[f32] = if tool == InkTool::Highlighter { &[4.0, 8.0, 12.0, 18.0, 24.0] } else { &[0.5, 1.0, 1.5, 2.5, 3.5, 5.0] };
                 for w in widths {
                     let label = crate::i18n::fmt(tl!("{n} pt"), &[("n", &w.to_string())]);
-                    mi_check(ui, app, &label, (set.width - w).abs() < 0.01, pen_id(tool), json!({"width": w}));
+                    mi_check(ui, app, &label, (set.width - w).abs() < 0.01, pen_command(tool), json!({"width": w}));
                 }
+                update_gallery_pen(app, custom, tool);
             });
         });
     });
     group(ui, "Convert", None, app, |ui, app| {
-        big(ui, app, "inkToShape", "Ink to\nShape", "draw.inkToShape", json!({}), false);
+        let on = app.session.view.draw.ink_to_shape;
+        big_toggle(ui, app, "inkToShape", "Ink to\nShape", "draw.inkToShape", on);
         big(ui, app, "inkToMath", "Ink to\nMath", "draw.inkToMath", json!({}), false);
     });
     group(ui, "Insert", None, app, |ui, app| {
         big(ui, app, "canvas", "Drawing\nCanvas", "insert.canvas", json!({}), false);
     });
     group(ui, "Replay", None, app, |ui, app| {
-        big(ui, app, "replay", "Ink\nReplay", "draw.replay", json!({}), false);
+        let on = app.session.view.draw.replay;
+        big_toggle(ui, app, "replay", "Ink\nReplay", "draw.replay", on);
     });
 }
 
+/// The command that picks up `tool`.
+fn pen_command(tool: wordcraft_doc::freeform::InkTool) -> &'static str {
+    use wordcraft_doc::freeform::InkTool;
+    match tool {
+        InkTool::Pen => "draw.pen",
+        InkTool::Pencil => "draw.pencil",
+        InkTool::Highlighter => "draw.highlighter",
+    }
+}
+
+/// After the colour or thickness menu changed `tool`'s settings, the gallery pen that was in use
+/// (`custom`) takes them too.
+fn update_gallery_pen(app: &mut WordApp, custom: Option<usize>, tool: wordcraft_doc::freeform::InkTool) {
+    let set = app.session.view.draw.settings(tool);
+    if let Some(p) = custom.and_then(|i| app.session.view.draw.pens.get_mut(i))
+        && p.kind == tool
+    {
+        p.color = set.color;
+        p.width = set.width;
+    }
+}
+
+/// A pen of the gallery: its kind's icon over a bar of its colour and thickness; a click picks it
+/// up, right-click offers Remove Pen.
+fn gallery_pen(ui: &mut Ui, app: &mut WordApp, i: usize, pen: wordcraft_engine::cmd::draw::CustomPen, active: bool) {
+    use wordcraft_doc::freeform::InkTool;
+    let t = Tokens::get(ui.ctx());
+    let (r, resp) = ui.allocate_exact_size(vec2(34.0, CONTENT_H), Sense::click());
+    crate::widgets::bg(ui, r, &resp, active, &t);
+    let icon = match pen.kind {
+        InkTool::Pen => "pen",
+        InkTool::Pencil => "pencil",
+        InkTool::Highlighter => "highlight",
+    };
+    let color = crate::theme::c32(pen.color);
+    icons::paint(ui.painter(), Rect::from_center_size(pos2(r.center().x, r.min.y + 20.0), vec2(28.0, 28.0)), icon, t.icon, color);
+    let bar = (pen.width * 0.6).clamp(1.5, 8.0);
+    let y = r.min.y + 46.0;
+    ui.painter().line_segment([pos2(r.min.x + 6.0, y), pos2(r.max.x - 6.0, y)], Stroke::new(bar, color));
+    let kind = tl!(match pen.kind {
+        InkTool::Pen => "Pen",
+        InkTool::Pencil => "Pencil",
+        InkTool::Highlighter => "Highlighter",
+    });
+    let size = crate::i18n::fmt(tl!("{n} pt"), &[("n", &pen.width.to_string())]);
+    let resp = resp.on_hover_text(format!("{kind}: {size}, #{}", pen.color.hex()));
+    if resp.clicked() {
+        let _ = app.run(pen_command(pen.kind), json!({"color": pen.color.hex(), "width": pen.width}));
+    }
+    resp.context_menu(|ui| {
+        if ui.button(tl!("Remove Pen")).clicked() {
+            let _ = app.run("draw.removePen", json!({"index": i}));
+            ui.close();
+        }
+    });
+}
+
+/// The Design tab's style set gallery in a box of its own, sized from its thumbnails and clipped
+/// to it, with a gap on each side: the Colors and Fonts column can't be drawn over, or cut by,
+/// the thumbnails (#638). Returns the box and the space the thumbnails used.
+fn style_set_box(app: &mut WordApp, ui: &mut Ui) -> (Rect, Rect) {
+    ui.add_space(4.0);
+    let (gallery, _) = ui.allocate_exact_size(vec2(crate::previews::STYLE_SET_GALLERY_W, CONTENT_H), Sense::hover());
+    let mut gui = ui.new_child(egui::UiBuilder::new().max_rect(gallery).layout(egui::Layout::left_to_right(egui::Align::Min)));
+    gui.set_clip_rect(gallery.intersect(ui.clip_rect()));
+    gui.spacing_mut().item_spacing = vec2(1.0, 1.0);
+    crate::previews::style_set_gallery(app, &mut gui);
+    ui.add_space(8.0);
+    (gallery, gui.min_rect())
+}
+
 fn design(app: &mut WordApp, ui: &mut Ui) {
     group(ui, "Themes", None, app, |ui, app| {
         menu_button(ui, app, "themes", Some("Themes"), "Themes", true, |ui, app| {
@@ -813,7 +988,7 @@ fn design(app: &mut WordApp, ui: &mut Ui) {
         });
     });
     group(ui, "Document Formatting", None, app, |ui, app| {
-        crate::previews::style_set_gallery(app, ui);
+        style_set_box(app, ui);
         stack(ui, |ui| {
             menu_button(ui, app, "colors", Some("Colors"), "Theme Colors", false, |ui, app| {
                 for (name, ..) in wordcraft_engine::cmd::design::THEMES {
@@ -856,17 +1031,24 @@ fn design(app: &mut WordApp, ui: &mut Ui) {
         menu_button(ui, app, "pageColor", Some("Page\nColor"), "Page Color", true, |ui, app| {
             mi(ui, app, "No Color", "design.pageColor", json!({"color": null}));
             let theme = app.session.doc.settings.theme_colors.clone();
-            if let Some(hex) = color_grid(ui, &theme) {
-                let _ = app.run("design.pageColor", json!({"color": hex}));
-                ui.close();
-            }
+            crate::colors::menu(ui, app, &theme, Target::cmd("design.pageColor"));
         });
         big(ui, app, "pageBorders", "Page\nBorders", "design.pageBorders", json!({}), false);
     });
 }
 
 fn layout(app: &mut WordApp, ui: &mut Ui) {
-    group(ui, "Page Setup", Some("ui.dialog"), app, |ui, app| {
+    group(ui, "Page Setup", Some("layout.pageSetup"), app, |ui, app| {
+        // Text Direction works on what the caret is in: table cells, a text box, else the section.
+        let dir = wordcraft_engine::cmd::page::text_direction_at(&app.session);
+        menu_button(ui, app, "textDirection", Some("Text\nDirection"), "Text Direction", true, |ui, app| {
+            use wordcraft_doc::props::TextDirection;
+            for (label, d) in
+                [("Horizontal", TextDirection::Horizontal), ("Rotate all text 90°", TextDirection::Down), ("Rotate all text 270°", TextDirection::Up)]
+            {
+                mi_check(ui, app, label, dir == d, "layout.textDirection", json!({"value": d.ooxml()}));
+            }
+        });
         menu_button(ui, app, "margins", Some("Margins"), "Margins", true, |ui, app| {
             for (l, k) in [
                 ("Normal  1\" all", "normal"),
@@ -916,11 +1098,16 @@ fn layout(app: &mut WordApp, ui: &mut Ui) {
                 {
                     mi(ui, app, l, "layout.lineNumbers", json!({"value": v}));
                 }
+                ui.separator();
+                mi(ui, app, "Line Numbering Options…", "ui.dialog", json!({"name": "lineNumbers"}));
             });
             let hy = app.session.doc.settings.auto_hyphenation;
             menu_button(ui, app, "hyphenation", Some("Hyphenation"), "Hyphenation", false, |ui, app| {
                 mi(ui, app, if hy { "✓ Automatic" } else { "Automatic" }, "layout.hyphenation", json!({"value": true}));
                 mi(ui, app, if hy { "None" } else { "✓ None" }, "layout.hyphenation", json!({"value": false}));
+                mi(ui, app, "Manual…", "ui.dialog", json!({"name": "manualHyphenation"}));
+                ui.separator();
+                mi(ui, app, "Hyphenation Options…", "ui.dialog", json!({"name": "hyphenation"}));
             });
         });
     });
@@ -932,12 +1119,15 @@ fn layout(app: &mut WordApp, ui: &mut Ui) {
             ui.label("");
             ui.label(egui::RichText::new(tl!("Spacing")).small().strong());
             ui.end_row();
-            let mut l = rp.indent_left / 72.0;
+            // Indents in the File › Options unit.
+            let u = crate::options::unit();
+            let k = u.pt_per_unit();
+            let mut l = rp.indent_left / k;
             let mut b = rp.space_before;
             ui.horizontal(|ui| {
                 ui.label(egui::RichText::new(tl!("Left:")).small());
-                if ui.add(egui::DragValue::new(&mut l).speed(0.05).range(-11.0..=22.0).suffix("\"").max_decimals(2)).changed() {
-                    let _ = app.run("para.indents", json!({"left": l * 72.0}));
+                if ui.add(egui::DragValue::new(&mut l).speed(3.6 / k).range(-792.0 / k..=1584.0 / k).suffix(u.suffix()).max_decimals(2)).changed() {
+                    let _ = app.run("para.indents", json!({"left": l * k}));
                 }
             });
             ui.label("");
@@ -948,12 +1138,12 @@ fn layout(app: &mut WordApp, ui: &mut Ui) {
                 }
             });
             ui.end_row();
-            let mut r = rp.indent_right / 72.0;
+            let mut r = rp.indent_right / k;
             let mut a = rp.space_after;
             ui.horizontal(|ui| {
                 ui.label(egui::RichText::new(tl!("Right:")).small());
-                if ui.add(egui::DragValue::new(&mut r).speed(0.05).range(-11.0..=22.0).suffix("\"").max_decimals(2)).changed() {
-                    let _ = app.run("para.indents", json!({"right": r * 72.0}));
+                if ui.add(egui::DragValue::new(&mut r).speed(3.6 / k).range(-792.0 / k..=1584.0 / k).suffix(u.suffix()).max_decimals(2)).changed() {
+                    let _ = app.run("para.indents", json!({"right": r * k}));
                 }
             });
             ui.label("");
@@ -1052,6 +1242,8 @@ fn references(app: &mut WordApp, ui: &mut Ui) {
         menu_button(ui, app, "toc", Some("Table of\nContents"), "Table of Contents", true, |ui, app| {
             mi(ui, app, "Automatic Table 1 (3 levels)", "references.toc", json!({"levels": 3}));
             mi(ui, app, "Automatic Table 2 (2 levels)", "references.toc", json!({"levels": 2, "title": "Table of Contents"}));
+            ui.separator();
+            mi(ui, app, "Custom Table of Contents…", "ui.dialog", json!({"name": "toc"}));
             mi(ui, app, "Remove Table of Contents", "references.removeToc", json!({}));
         });
         stack(ui, |ui| {
@@ -1076,7 +1268,18 @@ fn references(app: &mut WordApp, ui: &mut Ui) {
         big(ui, app, "researcher", "Researcher", "references.researcher", json!({}), false);
     });
     group(ui, "Citations & Bibliography", None, app, |ui, app| {
-        big(ui, app, "citation", "Insert\nCitation", "references.citation", json!({}), false);
+        // The document's sources to cite, then a new one (Create Source, #402).
+        menu_button(ui, app, "citation", Some("Insert\nCitation"), "Insert Citation", true, |ui, app| {
+            let sources: Vec<(String, String)> =
+                app.session.doc.sources.iter().map(|s| (s.tag.clone(), format!("{} — {}", s.author, s.title))).collect();
+            for (tag, label) in sources {
+                mi_text(ui, app, &label, "references.citation", json!({"tag": tag}));
+            }
+            if !app.session.doc.sources.is_empty() {
+                ui.separator();
+            }
+            mi(ui, app, "Add New Source…", "ui.dialog", json!({"name": "createSource"}));
+        });
         stack(ui, |ui| {
             small(ui, app, "sources", Some("Manage Sources"), "Manage Sources", "references.sources", json!({}), false);
             let current = app.session.bib_style.clone();
@@ -1115,7 +1318,19 @@ fn references(app: &mut WordApp, ui: &mut Ui) {
     });
     group(ui, "Table of Authorities", None, app, |ui, app| {
         big(ui, app, "markCitation", "Mark\nCitation", "references.markCitation", json!({}), false);
-        small(ui, app, "tableOfAuthorities", None, "Insert Table of Authorities", "references.tableOfAuthorities", json!({}), false);
+        stack(ui, |ui| {
+            small(
+                ui,
+                app,
+                "tableOfAuthorities",
+                Some("Insert Table of Authorities"),
+                "Insert Table of Authorities",
+                "references.tableOfAuthorities",
+                json!({}),
+                false,
+            );
+            small(ui, app, "update", Some("Update Table"), "Update Table", "references.updateAuthorities", json!({}), false);
+        });
     });
 }
 
@@ -1271,6 +1486,44 @@ fn review(app: &mut WordApp, ui: &mut Ui) {
     });
 }
 
+/// Developer › Controls: content controls.
+fn developer(app: &mut WordApp, ui: &mut Ui) {
+    let design = app.session.view.design_mode;
+    group(ui, "Controls", None, app, |ui, app| {
+        let rows: [[(&str, &str, &str); 3]; 3] = [
+            [
+                ("ccRichText", "Rich Text Content Control", "developer.richText"),
+                ("ccPlainText", "Plain Text Content Control", "developer.plainText"),
+                ("ccPicture", "Picture Content Control", "developer.picture"),
+            ],
+            [
+                ("ccGallery", "Building Block Gallery Content Control", "developer.buildingBlock"),
+                ("ccCheckBox", "Check Box Content Control", "developer.checkBox"),
+                ("ccComboBox", "Combo Box Content Control", "developer.comboBox"),
+            ],
+            [
+                ("ccDropDown", "Drop-Down List Content Control", "developer.dropDown"),
+                ("ccDate", "Date Picker Content Control", "developer.datePicker"),
+                ("ccRepeat", "Repeating Section Content Control", "developer.repeatingSection"),
+            ],
+        ];
+        stack(ui, |ui| {
+            for row in rows {
+                crate::widgets::row(ui, |ui| {
+                    for (icon, tip, id) in row {
+                        small(ui, app, icon, None, tip, id, json!({}), false);
+                    }
+                });
+                ui.add_space(3.0);
+            }
+        });
+        stack(ui, |ui| {
+            small(ui, app, "designMode", Some("Design Mode"), "Design Mode", "developer.designMode", json!({}), design);
+            small(ui, app, "properties", Some("Properties"), "Properties", "developer.properties", json!({}), false);
+        });
+    });
+}
+
 fn view(app: &mut WordApp, ui: &mut Ui) {
     let v = app.session.view.clone();
     group(ui, "Views", None, app, |ui, app| {
@@ -1304,6 +1557,10 @@ fn view(app: &mut WordApp, ui: &mut Ui) {
             if ui.checkbox(&mut n, tl!("Navigation Pane")).changed() {
                 let _ = app.run("view.navigationPane", json!({"value": n}));
             }
+            let mut w = v.hide_white_space;
+            if ui.checkbox(&mut w, tl!("Hide White Space")).changed() {
+                let _ = app.run("view.hideWhiteSpace", json!({"value": w}));
+            }
         });
     });
     group(ui, "Zoom", None, app, |ui, app| {
@@ -1339,6 +1596,67 @@ fn view(app: &mut WordApp, ui: &mut Ui) {
     group(ui, "Macros", None, app, |ui, app| {
         big(ui, app, "macros", "Macros", "tools.macros", json!({}), false);
     });
+    group(ui, "Templates", None, app, |ui, app| {
+        big(ui, app, "documentTemplate", "Templates", "tools.templates", json!({}), false);
+    });
+}
+
+/// The Outlining tab (Outline view): outline levels, moving, expanding and collapsing, what is
+/// shown, and closing the view.
+fn outlining(app: &mut WordApp, ui: &mut Ui) {
+    use wordcraft_engine::layout::outline::{BODY, para_level};
+    let o = app.session.view.outline.clone();
+    let level = app.session.doc.para_at(&app.session.sel.focus).map(|p| para_level(&app.session.doc, p)).unwrap_or(BODY);
+    let name = |l: u8| if l >= BODY { tl!("Body Text").to_string() } else { crate::i18n::fmt(tl!("Level {n}"), &[("n", &l.to_string())]) };
+    group(ui, "Outline Tools", None, app, |ui, app| {
+        stack(ui, |ui| {
+            crate::widgets::row(ui, |ui| {
+                small(ui, app, "outlineTop", None, "Promote to Heading 1", "outline.promoteToHeading1", json!({}), false);
+                small(ui, app, "outlinePromote", None, "Promote", "outline.promote", json!({}), false);
+                let levels: Vec<String> = (1..=BODY).map(name).collect();
+                if let Some(v) = combo(ui, "outlineLevel", 100.0, &name(level), &levels, None)
+                    && let Some(i) = levels.iter().position(|x| *x == v)
+                {
+                    let l = if i + 1 >= usize::from(BODY) { json!("body") } else { json!(i + 1) };
+                    let _ = app.run("outline.level", json!({ "level": l }));
+                }
+                small(ui, app, "outlineDemote", None, "Demote", "outline.demote", json!({}), false);
+                small(ui, app, "outlineBody", None, "Demote to Body Text", "outline.demoteToBody", json!({}), false);
+            });
+            ui.add_space(3.0);
+            crate::widgets::row(ui, |ui| {
+                small(ui, app, "outlineUp", None, "Move Up", "outline.moveUp", json!({}), false);
+                small(ui, app, "outlineDown", None, "Move Down", "outline.moveDown", json!({}), false);
+                small(ui, app, "outlineExpand", None, "Expand", "outline.expand", json!({}), false);
+                small(ui, app, "outlineCollapse", None, "Collapse", "outline.collapse", json!({}), false);
+                ui.add_space(6.0);
+                ui.label(egui::RichText::new(tl!("Show Level")).size(11.5));
+                let mut shown: Vec<String> = vec![tl!("All Levels").to_string()];
+                shown.extend((1..BODY).map(name));
+                let current = shown.get(usize::from(o.show_level)).cloned().unwrap_or_default();
+                if let Some(v) = combo(ui, "outlineShowLevel", 90.0, &current, &shown, None)
+                    && let Some(i) = shown.iter().position(|x| *x == v)
+                {
+                    let l = if i == 0 { json!("all") } else { json!(i) };
+                    let _ = app.run("outline.showLevel", json!({ "level": l }));
+                }
+            });
+            ui.add_space(3.0);
+            crate::widgets::row(ui, |ui| {
+                let mut f = !o.hide_formatting;
+                if ui.checkbox(&mut f, tl!("Show Text Formatting")).changed() {
+                    let _ = app.run("outline.showFormatting", json!({ "value": f }));
+                }
+                let mut first = o.first_line_only;
+                if ui.checkbox(&mut first, tl!("Show First Line Only")).changed() {
+                    let _ = app.run("outline.firstLineOnly", json!({ "value": first }));
+                }
+            });
+        });
+    });
+    group(ui, "Close", None, app, |ui, app| {
+        big(ui, app, "closeOutline", "Close Outline\nView", "outline.close", json!({}), false);
+    });
 }
 
 fn help(app: &mut WordApp, ui: &mut Ui) {
@@ -1351,6 +1669,119 @@ fn help(app: &mut WordApp, ui: &mut Ui) {
     });
 }
 
+/// SmartArt Design: the selected graphic's items (Add Shape, Promote, Demote, Text Pane), its
+/// layout (a gallery of previews), its colours and Reset.
+fn smart_art_design(app: &mut WordApp, ui: &mut Ui) {
+    use wordcraft_doc::smart_art::{SmartArtColors, SmartArtLayout};
+    let Some(g) = wordcraft_engine::cmd::smart_art::selected_smart_art(&app.session) else { return };
+    let theme = app.session.doc.settings.theme_colors.clone();
+    // The Text Pane's current item, else the last.
+    let current = app.smart_art_item.filter(|i| *i < g.items.len());
+    group(ui, "Create Graphic", None, app, |ui, app| {
+        big(ui, app, "addShape", "Add\nShape", "smartArt.addShape", current.map_or(json!({}), |i| json!({"after": i})), false);
+        stack(ui, |ui| {
+            let idx = current.map_or(json!({}), |i| json!({"index": i}));
+            small(ui, app, "promote", Some("Promote"), "Promote", "smartArt.promote", idx.clone(), false);
+            small(ui, app, "demote", Some("Demote"), "Demote", "smartArt.demote", idx, false);
+            small(ui, app, "textPane", Some("Text Pane"), "Text Pane", "smartArt.textPane", json!({}), app.session.view.smart_art_pane);
+        });
+    });
+    group(ui, "Layouts", None, app, |ui, app| {
+        let t = Tokens::get(ui.ctx());
+        egui::Grid::new("smart_art_layout_gallery").spacing(vec2(2.0, 2.0)).show(ui, |ui| {
+            for (k, layout) in SmartArtLayout::ALL.into_iter().enumerate() {
+                let (r, resp) = ui.allocate_exact_size(vec2(46.0, 31.0), Sense::click());
+                let on = g.layout == layout;
+                let fill = if on {
+                    t.checked
+                } else if resp.hovered() {
+                    t.hover
+                } else {
+                    t.ribbon
+                };
+                ui.painter().rect(r, 3.0, fill, Stroke::new(1.0, if on { t.accent } else { t.border }), egui::StrokeKind::Inside);
+                crate::dialogs_smart_art::preview(ui.painter(), r.shrink(2.0), layout, g.colors, &theme, t.text_dim);
+                if resp.on_hover_text(tl!(layout.label())).clicked() && !on {
+                    let _ = app.run("smartArt.layout", json!({"layout": layout.id()}));
+                }
+                if k % 4 == 3 {
+                    ui.end_row();
+                }
+            }
+        });
+    });
+    group(ui, "SmartArt Styles", None, app, |ui, app| {
+        menu_button(ui, app, "smartArtColors", Some("Change\nColors"), "Change Colors", true, |ui, app| {
+            for colors in SmartArtColors::ALL {
+                let on = g.colors == colors;
+                let resp = ui.add(egui::Button::new(crate::dialogs_smart_art::colors_label(colors)).selected(on).min_size(vec2(200.0, 24.0)));
+                let sw = Rect::from_min_size(pos2(resp.rect.right() - 74.0, resp.rect.center().y - 6.0), vec2(66.0, 12.0));
+                crate::dialogs_smart_art::swatches(ui.painter(), sw, colors, &theme);
+                if resp.clicked() {
+                    let _ = app.run("smartArt.colors", json!({"variant": colors.id()}));
+                    ui.close();
+                }
+            }
+        });
+    });
+    group(ui, "Reset", None, app, |ui, app| {
+        big(ui, app, "resetGraphic", "Reset\nGraphic", "smartArt.reset", json!({}), false);
+    });
+}
+
+/// Chart Design: the selected chart's elements (title, legend, data labels), its data and type,
+/// and its size.
+fn chart_design(app: &mut WordApp, ui: &mut Ui) {
+    let Some(chart) = wordcraft_engine::cmd::chart::selected_chart(&app.session) else { return };
+    group(ui, "Chart Layouts", None, app, |ui, app| {
+        menu_button(ui, app, "chartTitle", Some("Chart Title"), "Chart Title", true, |ui, app| {
+            mi_check(ui, app, "None", chart.title.is_none(), "chart.title", json!({"text": null}));
+            let text = chart.title.clone().unwrap_or_else(|| tl!("Chart Title").to_string());
+            mi_check(ui, app, "Above Chart", chart.title.is_some(), "chart.title", json!({"text": text}));
+        });
+        menu_button(ui, app, "legend", Some("Legend"), "Legend", true, |ui, app| {
+            mi_check(ui, app, "None", chart.legend.is_none(), "chart.legend", json!({"pos": "none"}));
+            for (label, pos) in [
+                ("Right", wordcraft_doc::chart::LegendPos::Right),
+                ("Top", wordcraft_doc::chart::LegendPos::Top),
+                ("Left", wordcraft_doc::chart::LegendPos::Left),
+                ("Bottom", wordcraft_doc::chart::LegendPos::Bottom),
+            ] {
+                mi_check(ui, app, label, chart.legend == Some(pos), "chart.legend", json!({"pos": pos.id()}));
+            }
+        });
+        menu_button(ui, app, "dataLabels", Some("Data Labels"), "Data Labels", true, |ui, app| {
+            mi_check(ui, app, "None", !chart.data_labels, "chart.dataLabels", json!({"on": false}));
+            mi_check(ui, app, "Show", chart.data_labels, "chart.dataLabels", json!({"on": true}));
+        });
+    });
+    group(ui, "Data", None, app, |ui, app| {
+        big(ui, app, "chartData", "Edit\nData", "chart.editData", json!({}), false);
+    });
+    group(ui, "Type", None, app, |ui, app| {
+        big(ui, app, "changeChartType", "Change\nChart Type", "chart.type", json!({}), false);
+    });
+    group(ui, "Size", None, app, |ui, app| {
+        let (w0, h0) =
+            wordcraft_engine::cmd::objects::selected(&app.session).and_then(|(_, o)| o.frame().map(|(w, h, _)| (w, h))).unwrap_or((0.0, 0.0));
+        stack(ui, |ui| {
+            for (label, key, v0) in [("H:", "height", h0), ("W:", "width", w0)] {
+                crate::widgets::row(ui, |ui| {
+                    ui.label(egui::RichText::new(tl!(label)).small());
+                    let mut v = v0;
+                    let r = ui.add(egui::DragValue::new(&mut v).speed(1.0).range(36.0..=2000.0).suffix(" pt"));
+                    if r.changed() {
+                        if r.dragged() && !r.drag_started() {
+                            app.session.join_next_undo();
+                        }
+                        let _ = app.run("picture.size", json!({key: v, "lockAspect": false}));
+                    }
+                });
+            }
+        });
+    });
+}
+
 /// Shape Format: fill, outline and effects of the selected shape, and its arrangement.
 fn shape_format(app: &mut WordApp, ui: &mut Ui) {
     let (stroke, glow_size) = match wordcraft_engine::cmd::objects::selected(&app.session) {
@@ -1362,17 +1793,11 @@ fn shape_format(app: &mut WordApp, ui: &mut Ui) {
         stack(ui, |ui| {
             menu_button(ui, app, "shading", Some("Shape Fill"), "Shape Fill", false, |ui, app| {
                 mi(ui, app, "No Color", "shape.fill", json!({"color": null}));
-                if let Some(hex) = color_grid(ui, &theme) {
-                    let _ = app.run("shape.fill", json!({"color": hex}));
-                    ui.close();
-                }
+                crate::colors::menu(ui, app, &theme, Target::cmd("shape.fill"));
             });
             menu_button(ui, app, "pen", Some("Shape Outline"), "Shape Outline", false, |ui, app| {
                 mi(ui, app, "No Color", "shape.outline", json!({"color": null}));
-                if let Some(hex) = color_grid(ui, &theme) {
-                    let _ = app.run("shape.outline", json!({"color": hex}));
-                    ui.close();
-                }
+                crate::colors::menu(ui, app, &theme, Target::cmd("shape.outline"));
                 ui.separator();
                 ui.menu_button(tl!("Weight"), |ui| {
                     let color = stroke.unwrap_or(wordcraft_doc::Rgb::BLACK).hex();
@@ -1386,6 +1811,7 @@ fn shape_format(app: &mut WordApp, ui: &mut Ui) {
             });
         });
     });
+    alt_text_group(ui, app);
     if wordcraft_engine::cmd::canvas::selected_canvas(&app.session).is_some() {
         group(ui, "Drawing Canvas", None, app, |ui, app| {
             menu_button(ui, app, "canvas", Some("Drawing\nCanvas"), "Drawing Canvas", true, |ui, app| {
@@ -1399,6 +1825,21 @@ fn shape_format(app: &mut WordApp, ui: &mut Ui) {
             });
         });
     }
+    group(ui, "WordArt Styles", None, app, |ui, app| {
+        menu_button(ui, app, "wordArt", Some("Styles"), "WordArt Styles", true, |ui, app| {
+            crate::wordart_menus::style_gallery(ui, app, "wordArt.style")
+        });
+        stack(ui, |ui| {
+            menu_button(ui, app, "textFill", Some("Text Fill"), "Text Fill", false, |ui, app| crate::wordart_menus::fill_menu(ui, app, &theme));
+            let outline = crate::wordart_menus::current_outline(app);
+            menu_button(ui, app, "textOutline", Some("Text Outline"), "Text Outline", false, |ui, app| {
+                crate::wordart_menus::outline_menu(ui, app, &theme, outline)
+            });
+            menu_button(ui, app, "transform", Some("Text Effects"), "Text Effects", false, |ui, app| {
+                crate::wordart_menus::effects_menu(ui, app, &theme, true)
+            });
+        });
+    });
     shape_text_group(app, ui);
     group(ui, "Arrange", None, app, |ui, app| {
         big(ui, app, "position", "Position", "arrange.position", json!({}), false);
@@ -1464,6 +1905,13 @@ fn shape_text_group(app: &mut WordApp, ui: &mut Ui) {
     });
 }
 
+/// Picture/Shape Format › Accessibility: Alt Text opens the Alt Text pane.
+fn alt_text_group(ui: &mut Ui, app: &mut WordApp) {
+    group(ui, "Accessibility", None, app, |ui, app| {
+        big(ui, app, "altText", "Alt\nText", "view.altTextPane", json!({"value": true}), false);
+    });
+}
+
 /// Shape Format › Shape Effects: Shadow, Glow and Soft Edges, each with presets and a "No …" entry.
 fn shape_effects_menu(ui: &mut Ui, app: &mut WordApp, theme: &[wordcraft_doc::Rgb], glow_size: Option<f32>) {
     ui.menu_button(tl!("Shadow"), |ui| {
@@ -1481,10 +1929,8 @@ fn shape_effects_menu(ui: &mut Ui, app: &mut WordApp, theme: &[wordcraft_doc::Rg
         }
         ui.separator();
         ui.menu_button(tl!("Glow Colors"), |ui| {
-            if let Some(hex) = color_grid(ui, theme) {
-                let _ = app.run("shape.effects", json!({"glow": {"color": hex, "size": glow_size.unwrap_or(8.0)}}));
-                ui.close();
-            }
+            let target = Target::at("shape.effects", json!({"glow": {"color": null, "size": glow_size.unwrap_or(8.0)}}), "/glow/color");
+            crate::colors::menu(ui, app, theme, target);
         });
     });
     ui.menu_button(tl!("Soft Edges"), |ui| {
@@ -1519,10 +1965,7 @@ fn picture_format(app: &mut WordApp, ui: &mut Ui) {
         });
         menu_button(ui, app, "icons", Some("Icon Color"), "Recolor a one-color picture, such as an icon", true, |ui, app| {
             let theme = app.session.doc.settings.theme_colors.clone();
-            if let Some(hex) = color_grid(ui, &theme) {
-                let _ = app.run("picture.iconColor", json!({"color": hex}));
-                ui.close();
-            }
+            crate::colors::menu(ui, app, &theme, Target::cmd("picture.iconColor"));
         });
         menu_button(ui, app, "picture", Some("Transparency"), "Picture transparency", true, |ui, app| {
             for v in [0.0, 15.0, 30.0, 50.0, 65.0, 80.0, 95.0] {
@@ -1552,6 +1995,7 @@ fn picture_format(app: &mut WordApp, ui: &mut Ui) {
             }
         });
     });
+    alt_text_group(ui, app);
     group(ui, "Arrange", None, app, |ui, app| {
         big(ui, app, "position", "Position", "arrange.position", json!({}), false);
         wrap_menu(ui, app);
@@ -1707,11 +2151,7 @@ fn table_design(app: &mut WordApp, ui: &mut Ui) {
             split(ui, app, "shading", "Shading", "table.shading", json!({"color": app.canvas.last_shading.clone()}), false, None, |ui, app| {
                 mi(ui, app, "No Color", "table.shading", json!({"color": null}));
                 let theme = app.session.doc.settings.theme_colors.clone();
-                if let Some(hex) = color_grid(ui, &theme) {
-                    app.canvas.last_shading = hex.clone();
-                    let _ = app.run("table.shading", json!({"color": hex}));
-                    ui.close();
-                }
+                crate::colors::menu(ui, app, &theme, Target::cmd("table.shading").remember(Remember::Shading));
             });
         });
     });
@@ -1742,14 +2182,27 @@ fn cell_size_boxes(ui: &mut Ui, app: &mut WordApp) {
     let row = t.rows.get(r).map(|x| x.props.clone()).unwrap_or_default();
     let stored_w = t.grid.get(t.grid_col(r, c)).copied();
     let laid = app.session.layout().pages.iter().flat_map(|pg| pg.items.iter()).find_map(|it| match it {
-        wordcraft_layout::Placed::Cell { rect, table, row, cell, story: st } if *table == tp && *row == r && *cell == c && *st == story => {
+        wordcraft_layout::Placed::Cell { rect, table, row, cell, story: st, .. } if *table == tp && *row == r && *cell == c && *st == story => {
             Some(*rect)
         }
         _ => None,
     });
-    let unit = wordcraft_geom::Unit::default();
+    // The row's own height: a vertically merged cell's box spans several rows, so take the
+    // shortest box in this row.
+    let row_h = app
+        .session
+        .layout()
+        .pages
+        .iter()
+        .flat_map(|pg| pg.items.iter())
+        .filter_map(|it| match it {
+            wordcraft_layout::Placed::Cell { rect, table, row, story: st, .. } if *table == tp && *row == r && *st == story => Some(rect.h),
+            _ => None,
+        })
+        .reduce(f32::min);
+    let unit = crate::options::unit();
     let k = unit.pt_per_unit();
-    let h0 = row.height.or(laid.map(|x| x.h)).unwrap_or(0.0);
+    let h0 = row.height.or(row_h).unwrap_or(0.0);
     let w0 = laid.map(|x| x.w).or(stored_w).unwrap_or(0.0);
     let exact = row.height_rule == wordcraft_doc::props::HeightRule::Exact;
     // The edited value in points, and whether it continues a drag (joins the previous Undo step).
@@ -1874,6 +2327,26 @@ mod tests {
         wordcraft_engine::cmd::insert::base64_encode(&b)
     }
 
+    /// The style set gallery fills exactly its own box and the next control starts after a gap,
+    /// so Colors and Fonts can't overlap the thumbnails (#638).
+    #[test]
+    fn design_style_set_gallery_stays_in_its_box() {
+        let mut app = WordApp::new(Session::new(wordcraft_doc::Document::new()), crate::Services::default());
+        let mut seen = None;
+        let mut h = egui_kittest::Harness::builder().with_size(vec2(1440.0, 200.0)).build_ui(|ui| {
+            ui.horizontal_top(|ui| {
+                let (gallery, used) = style_set_box(&mut app, ui);
+                seen = Some((gallery, used, ui.cursor().min.x));
+            });
+        });
+        h.run_steps(2);
+        drop(h);
+        let (gallery, used, next_x) = seen.unwrap();
+        assert!((gallery.width() - crate::previews::STYLE_SET_GALLERY_W).abs() < 0.01);
+        assert!(used.right() <= gallery.right() + 0.01, "{used:?} {gallery:?}");
+        assert!(next_x >= gallery.right() + 8.0 - 0.01, "{next_x} {gallery:?}");
+    }
+
     #[test]
     fn picture_format_tab_appears_when_picture_selected() {
         let mut s = Session::new(wordcraft_doc::Document::new());
@@ -1898,6 +2371,55 @@ mod tests {
         assert!(!contextual_tabs(&s).contains(&"Shape Format"));
     }
 
+    #[test]
+    fn page_setup_launcher_opens_the_dialog() {
+        // A group launcher runs its command with no parameters (#471).
+        let mut app = crate::WordApp::new(Session::new(wordcraft_doc::Document::new()), crate::Services::default());
+        app.run("layout.pageSetup", json!({})).unwrap();
+        assert!(matches!(app.dialog, Some(crate::dialogs::Dialog::PageSetup { .. })));
+        // `ui.dialog` needs a dialog name, so it can't be a launcher.
+        let launchers: Vec<&str> = include_str!("ribbon.rs")
+            .split("group(ui, \"")
+            .filter_map(|g| g.split_once('"')?.1.strip_prefix(", Some(\"")?.split('"').next())
+            .collect();
+        assert!(launchers.contains(&"layout.pageSetup"), "{launchers:?}");
+        assert!(!launchers.contains(&"ui.dialog"), "{launchers:?}");
+    }
+
+    #[test]
+    fn smart_art_picker_inserts_and_design_tab_follows_the_selection() {
+        let mut app = crate::WordApp::new(Session::new(wordcraft_doc::Document::new()), Default::default());
+        // Insert › SmartArt without a layout opens the picker.
+        let _ = app.run("insert.smartArt", json!({}));
+        assert_eq!(app.dialog.as_ref().map(crate::dialogs::Dialog::name), Some("insertSmartArt"));
+        app.dialog = None;
+        app.run("insert.smartArt", json!({"layout": "cycle"})).unwrap();
+        assert!(contextual_tabs(&app.session).contains(&"SmartArt Design"));
+        app.run("smartArt.textPane", json!({})).unwrap();
+        assert!(app.session.view.smart_art_pane);
+        app.session.run("select.collapse", &json!({"end": true})).unwrap();
+        app.session.run("text.insert", &json!({"text": "x"})).unwrap();
+        assert!(!contextual_tabs(&app.session).contains(&"SmartArt Design"));
+    }
+
+    #[test]
+    fn chart_design_tab_appears_when_chart_selected_and_buttons_open_dialogs() {
+        let mut app = crate::WordApp::new(Session::new(wordcraft_doc::Document::new()), Default::default());
+        // Insert › Chart without a type opens the gallery; choosing inserts.
+        let _ = app.run("insert.chart", json!({}));
+        assert_eq!(app.dialog.as_ref().map(crate::dialogs::Dialog::name), Some("insertChart"));
+        app.dialog = None;
+        app.run("insert.chart", json!({"type": "doughnut"})).unwrap();
+        assert!(contextual_tabs(&app.session).contains(&"Chart Design"));
+        let _ = app.run("chart.editData", json!({}));
+        assert_eq!(app.dialog.as_ref().map(crate::dialogs::Dialog::name), Some("chartData"));
+        let _ = app.run("chart.type", json!({}));
+        assert_eq!(app.dialog.as_ref().map(crate::dialogs::Dialog::name), Some("changeChartType"));
+        app.session.run("select.collapse", &json!({"end": true})).unwrap();
+        app.session.run("text.insert", &json!({"text": "x"})).unwrap();
+        assert!(!contextual_tabs(&app.session).contains(&"Chart Design"));
+    }
+
     #[test]
     fn resolve_tab_falls_back_when_contextual_tab_expires() {
         let all = ["Home", "Table Design", "Picture Format"];
diff --git a/crates/ui-egui/src/scroll.rs b/crates/ui-egui/src/scroll.rs
index 6ba32b76a8..358ac48c9c 100644
--- a/crates/ui-egui/src/scroll.rs
+++ b/crates/ui-egui/src/scroll.rs
@@ -7,6 +7,12 @@
 //! - after a touchpad flick the page coasts and slows down ([`Momentum`]), on platforms whose
 //!   system doesn't already send momentum events (not macOS, Windows or the web);
 //! - a mouse-wheel notch scrolls about three text lines and eases in over ~0.1 s, like egui.
+//!
+//! With animation effects off ([`crate::theme::Animations`]) nothing eases: a notch scrolls the
+//! page its whole distance at once, and so do egui's own scroll areas ([`unsmoothed_scroll`]).
+//! Ctrl/⌘+wheel zooms in whole steps, each at once ([`CanvasScroll::zoom`]). Touchpad momentum
+//! stays: it carries on the fingers' own movement, as the momentum macOS and Windows send does
+//! whatever their animation setting.
 
 use egui::{Event, InputOptions, Modifiers, MouseWheelUnit, TouchPhase, Vec2};
 
@@ -37,6 +43,17 @@ const MAX_SPEED: f32 = 8000.0;
 /// Exponential decay rate of the coast (1/s): speed falls to 1/e every ~0.33 s.
 const DECAY: f32 = 3.0;
 
+/// With animation effects off, Ctrl/⌘+wheel zooms in steps of this size (the natural logarithm of
+/// the factor: about 10%). A mouse-wheel notch is two steps at once, the same zoom as with
+/// animation effects on. Turns that arrive in small pieces (a touchpad pinch that Windows reports
+/// as Ctrl+wheel, a free-spinning or high-resolution wheel) add up to a step first, so the zoom
+/// moves in a few plain steps instead of gliding.
+const ZOOM_STEP: f32 = 0.1;
+/// Part of a zoom step is forgotten after this many seconds without more Ctrl/⌘+wheel input.
+const ZOOM_STEP_IDLE: f64 = 0.75;
+/// Most zoom steps taken from one frame's input (the zoom itself is clamped to 10–500%).
+const MAX_ZOOM_STEPS: f32 = 64.0;
+
 /// Kinetic scrolling for touchpads: tracks the scroll velocity while the fingers move and keeps
 /// scrolling with exponentially decaying speed after they lift. Time-based, so frame-rate
 /// independent. Deltas are in screen points, positive = content moves down/right.
@@ -129,19 +146,25 @@ impl Momentum {
     }
 }
 
-/// The canvas's scrolling state: momentum plus the not-yet-scrolled part of wheel notches.
+/// The canvas's scrolling state: momentum plus the not-yet-scrolled part of wheel notches, and
+/// the part of a zoom step the wheel has turned so far.
 #[derive(Clone, Debug, Default)]
 pub struct CanvasScroll {
     momentum: Momentum,
     /// Wheel distance still to scroll, eased out over a few frames.
     pending: Vec2,
+    /// Ctrl/⌘+wheel zoom not yet applied (natural logarithm, less than a [`ZOOM_STEP`]), and the
+    /// input time it last grew. Only used with animation effects off.
+    zoom_pending: f32,
+    zoom_time: f64,
 }
 
 impl CanvasScroll {
     /// This frame's scroll delta in screen points (positive = content moves down/right) from the
     /// wheel/touchpad events in `input`. `hovered`: the pointer is over the canvas (only then do
     /// its wheel events scroll it). `notch`: points per wheel notch. `page`: viewport height.
-    pub fn frame(&mut self, input: &egui::InputState, opts: &InputOptions, hovered: bool, notch: f32, page: f32) -> Vec2 {
+    /// `animate`: animation effects are on, so wheel notches ease in rather than land at once.
+    pub fn frame(&mut self, input: &egui::InputState, opts: &InputOptions, hovered: bool, notch: f32, page: f32, animate: bool) -> Vec2 {
         let notch = if notch.is_finite() { notch.clamp(1.0, 1000.0) } else { NOTCH_PX };
         let page = if page.is_finite() { page.clamp(0.0, 100_000.0) } else { 0.0 };
         // Browsers report lines (Firefox: three per notch) where native platforms report notches.
@@ -196,9 +219,10 @@ impl CanvasScroll {
         if SYNTH_MOMENTUM && !fed {
             now += self.momentum.tick(dt);
         }
-        // Ease wheel notches in: 90% of the way in 0.1 s (egui's curve).
+        // Ease wheel notches in: 90% of the way in 0.1 s (egui's curve). Without animation effects
+        // the whole distance lands this frame.
         if self.pending != Vec2::ZERO {
-            let t = if dt.is_finite() { egui::emath::exponential_smooth_factor(0.9, 0.1, dt.clamp(0.0, MAX_DT)) } else { 1.0 };
+            let t = if animate && dt.is_finite() { egui::emath::exponential_smooth_factor(0.9, 0.1, dt.clamp(0.0, MAX_DT)) } else { 1.0 };
             let ease = |pending: f32| if pending.abs() < 1.0 { pending } else { pending * t };
             let step = Vec2::new(ease(self.pending.x), ease(self.pending.y));
             now += step;
@@ -217,6 +241,42 @@ impl CanvasScroll {
     pub fn is_animating(&self) -> bool {
         self.pending != Vec2::ZERO || self.momentum.is_active()
     }
+
+    /// This frame's zoom factor from Ctrl/⌘+wheel and pinch gestures (1.0: none). With `animate`
+    /// it is egui's, which eases a wheel notch's zoom in over a few frames. Without, the wheel
+    /// zooms in whole steps ([`ZOOM_STEP`]), each at once, however finely the turns arrive; a
+    /// pinch the system reports as a pinch still follows the fingers.
+    pub fn zoom(&mut self, input: &egui::InputState, opts: &InputOptions, animate: bool) -> f32 {
+        // Fingers on a touch screen are measured directly, never eased.
+        if animate || input.multi_touch().is_some() {
+            self.zoom_pending = 0.0;
+            return input.zoom_delta();
+        }
+        let mut zoom = 1.0_f32;
+        let mut turned = 0.0_f32;
+        for event in &input.events {
+            match event {
+                Event::Zoom(factor) => zoom *= factor,
+                Event::MouseWheel { unit, delta, phase: TouchPhase::Move, modifiers } if modifiers.matches_any(opts.zoom_modifier) => {
+                    let d = egui_points(*unit, *delta, input, opts);
+                    turned += opts.scroll_zoom_speed * (d.x + d.y);
+                }
+                _ => {}
+            }
+        }
+        if turned != 0.0 {
+            if input.time - self.zoom_time > ZOOM_STEP_IDLE {
+                self.zoom_pending = 0.0;
+            }
+            self.zoom_time = input.time;
+            let total = self.zoom_pending + turned;
+            // A hair of tolerance: a notch's two steps mustn't come out as 1.9999.
+            let steps = if total.is_finite() { (total / ZOOM_STEP + 1e-3_f32.copysign(total)).trunc() } else { 0.0 };
+            self.zoom_pending = if total.is_finite() { total - steps * ZOOM_STEP } else { 0.0 };
+            zoom *= (steps.clamp(-MAX_ZOOM_STEPS, MAX_ZOOM_STEPS) * ZOOM_STEP).exp();
+        }
+        if zoom.is_finite() && zoom > 0.0 { zoom } else { 1.0 }
+    }
 }
 
 /// Shift scrolls sideways and Alt scrolls vertically, like egui's own scroll areas.
@@ -230,6 +290,33 @@ fn axis_lock(d: Vec2, modifiers: Modifiers, opts: &InputOptions) -> Vec2 {
     }
 }
 
+/// A wheel event's delta in points the way egui's own scroll areas count it: a line is
+/// `line_scroll_speed` points and a page is the window's height.
+fn egui_points(unit: MouseWheelUnit, delta: Vec2, input: &egui::InputState, opts: &InputOptions) -> Vec2 {
+    let d = match unit {
+        MouseWheelUnit::Point => delta,
+        MouseWheelUnit::Line => delta * opts.line_scroll_speed,
+        MouseWheelUnit::Page => delta * input.viewport_rect().height(),
+    };
+    if d.is_finite() { d } else { Vec2::ZERO }
+}
+
+/// This frame's wheel scrolling for egui's own scroll areas (panes, lists, dialogs, Backstage)
+/// with nothing held back: egui eases a wheel notch in over the next frames
+/// (`InputState::smooth_scroll_delta`) and has no switch for it, so with animation effects off the
+/// app puts this in its place every frame. Ctrl/⌘+wheel is left out, as in egui: it zooms.
+pub fn unsmoothed_scroll(input: &egui::InputState, opts: &InputOptions) -> Vec2 {
+    let mut total = Vec2::ZERO;
+    for event in &input.events {
+        if let Event::MouseWheel { unit, delta, phase: TouchPhase::Move, modifiers } = event
+            && !modifiers.matches_any(opts.zoom_modifier)
+        {
+            total += axis_lock(egui_points(*unit, *delta, input, opts), *modifiers, opts);
+        }
+    }
+    if total.is_finite() { total } else { Vec2::ZERO }
+}
+
 /// Points per wheel notch at `zoom` (1.0 = 100%): more when zoomed in, less when zoomed out, but
 /// gently, so zoomed-out overviews don't crawl and close-ups don't jump.
 pub fn notch_px(zoom: f32) -> f32 {
@@ -309,6 +396,111 @@ mod tests {
         assert!(!m.is_active());
     }
 
+    fn wheel(unit: MouseWheelUnit, delta: Vec2, modifiers: Modifiers) -> Event {
+        Event::MouseWheel { unit, delta, phase: TouchPhase::Move, modifiers }
+    }
+
+    /// One 60 fps frame over a tall egui scroll area with the pointer on it; `animate` false puts
+    /// [`unsmoothed_scroll`] in place of egui's eased delta, as the app does. Returns the scroll
+    /// area's offset and the frame's [`CanvasScroll::zoom`] (its state is kept with the context).
+    fn egui_frame(ctx: &egui::Context, frame_no: &mut u32, animate: bool, mut events: Vec<Event>) -> (f32, f32) {
+        *frame_no += 1;
+        events.insert(0, Event::PointerMoved(egui::pos2(50.0, 50.0)));
+        let screen = egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(400.0, 300.0));
+        let input = egui::RawInput { events, time: Some(f64::from(*frame_no) / 60.0), screen_rect: Some(screen), ..Default::default() };
+        let mut seen = (0.0, 1.0);
+        ctx.run_ui(input, |ui| {
+            let opts = ui.ctx().options(|o| o.input_options);
+            if !animate {
+                ui.ctx().input_mut(|i| i.smooth_scroll_delta = unsmoothed_scroll(i, &opts));
+            }
+            let id = egui::Id::new("canvas scroll under test");
+            let mut scroll = ui.data(|d| d.get_temp::<CanvasScroll>(id)).unwrap_or_default();
+            let zoom = ui.input(|i| scroll.zoom(i, &opts, animate));
+            ui.data_mut(|d| d.insert_temp(id, scroll));
+            let out = egui::ScrollArea::vertical().show(ui, |ui| ui.allocate_space(egui::vec2(100.0, 5000.0)));
+            seen = (out.state.offset.y, zoom);
+        })
+        .drop_without_applying_deltas();
+        seen
+    }
+
+    /// egui's own scroll areas ease a wheel notch in over several frames; with animation effects
+    /// off the notch lands whole in its frame, and nothing more arrives afterwards.
+    #[test]
+    fn egui_scroll_areas_take_a_wheel_notch_at_once_without_animation() {
+        let line = InputOptions::default().line_scroll_speed;
+        let notch = || vec![wheel(MouseWheelUnit::Line, Vec2::new(0.0, -1.0), Modifiers::NONE)];
+        let settle = |ctx: &egui::Context, n: &mut u32, animate| (0..40).map(|_| egui_frame(ctx, n, animate, Vec::new()).0).last().unwrap();
+
+        let (ctx, mut n) = (egui::Context::default(), 0);
+        egui_frame(&ctx, &mut n, true, Vec::new());
+        let first = egui_frame(&ctx, &mut n, true, notch()).0;
+        assert!(first > 0.0 && first < line, "egui eases the notch in: {first}");
+        assert!((settle(&ctx, &mut n, true) - line).abs() < 0.5);
+
+        let (ctx, mut n) = (egui::Context::default(), 0);
+        egui_frame(&ctx, &mut n, false, Vec::new());
+        assert_eq!(egui_frame(&ctx, &mut n, false, notch()).0, line, "the whole notch in one frame");
+        assert_eq!(settle(&ctx, &mut n, false), line, "and none of egui's leftover easing after it");
+        // Shift turns the notch sideways, and Ctrl/⌘+wheel zooms rather than scrolls, as in egui.
+        assert_eq!(egui_frame(&ctx, &mut n, false, vec![wheel(MouseWheelUnit::Line, Vec2::new(0.0, -1.0), Modifiers::SHIFT)]).0, line);
+        assert_eq!(egui_frame(&ctx, &mut n, false, vec![wheel(MouseWheelUnit::Line, Vec2::new(0.0, -1.0), Modifiers::COMMAND)]).0, line);
+        // Touchpad deltas pass through as they are.
+        assert_eq!(egui_frame(&ctx, &mut n, false, vec![wheel(MouseWheelUnit::Point, Vec2::new(0.0, -3.0), Modifiers::NONE)]).0, line + 3.0);
+        // A junk delta scrolls nothing. Last: egui's own wheel state doesn't recover from it.
+        let junk = vec![wheel(MouseWheelUnit::Line, Vec2::new(0.0, f32::NEG_INFINITY), Modifiers::NONE)];
+        assert_eq!(egui_frame(&ctx, &mut n, false, junk).0, line + 3.0);
+    }
+
+    /// Ctrl/⌘+wheel: egui spreads a notch's zoom over several frames. With animation effects off
+    /// the wheel zooms in whole steps, each at once: a notch is two steps in its own frame, and
+    /// turns that arrive in small pieces add up to a step first rather than each zooming a little.
+    #[test]
+    fn wheel_zoom_steps_at_once_without_animation() {
+        let opts = InputOptions::default();
+        let notch_zoom = (opts.scroll_zoom_speed * opts.line_scroll_speed).exp();
+        let step = ZOOM_STEP.exp();
+        let turn = |notches: f32| vec![wheel(MouseWheelUnit::Line, Vec2::new(0.0, notches), Modifiers::COMMAND)];
+        let near = |a: f32, b: f32| (a - b).abs() < 1e-5;
+
+        let (ctx, mut n) = (egui::Context::default(), 0);
+        egui_frame(&ctx, &mut n, true, Vec::new());
+        let first = egui_frame(&ctx, &mut n, true, turn(1.0)).1;
+        assert!(first > 1.0 && first < notch_zoom, "egui eases the zoom in: {first} of {notch_zoom}");
+
+        let (ctx, mut n) = (egui::Context::default(), 0);
+        egui_frame(&ctx, &mut n, false, Vec::new());
+        let zoom = egui_frame(&ctx, &mut n, false, turn(1.0)).1;
+        assert!(near(zoom, notch_zoom) && near(zoom, step * step), "a notch is two steps at once: {zoom}");
+        assert_eq!(egui_frame(&ctx, &mut n, false, Vec::new()).1, 1.0, "nothing left for later frames");
+        assert!(near(egui_frame(&ctx, &mut n, false, turn(-1.0)).1, 1.0 / notch_zoom));
+        // Quarter notches, as a touchpad pinch or a free-spinning wheel sends them: a step with
+        // every second one and nothing in between, never a little with each.
+        let zooms: Vec<f32> = (0..4).map(|_| egui_frame(&ctx, &mut n, false, turn(0.25)).1).collect();
+        assert!(zooms[0] == 1.0 && near(zooms[1], step) && zooms[2] == 1.0 && near(zooms[3], step), "{zooms:?}");
+        let zooms: Vec<f32> = (0..4).map(|_| egui_frame(&ctx, &mut n, false, turn(-0.25)).1).collect();
+        assert!(zooms[0] == 1.0 && near(zooms[1], 1.0 / step) && zooms[2] == 1.0 && near(zooms[3], 1.0 / step), "{zooms:?}");
+        // Part of a step doesn't wait for ever: after a pause the count starts again.
+        assert_eq!(egui_frame(&ctx, &mut n, false, turn(0.25)).1, 1.0);
+        for _ in 0..60 {
+            assert_eq!(egui_frame(&ctx, &mut n, false, Vec::new()).1, 1.0);
+        }
+        assert_eq!(egui_frame(&ctx, &mut n, false, turn(0.25)).1, 1.0, "the quarter turn of a second ago has lapsed");
+        assert!(near(egui_frame(&ctx, &mut n, false, turn(0.25)).1, step));
+        // A pinch the system reports as a pinch arrives as a zoom factor of its own and follows the
+        // fingers; a plain notch doesn't zoom.
+        assert_eq!(egui_frame(&ctx, &mut n, false, vec![Event::Zoom(1.5)]).1, 1.5);
+        assert_eq!(egui_frame(&ctx, &mut n, false, vec![wheel(MouseWheelUnit::Line, Vec2::new(0.0, 1.0), Modifiers::NONE)]).1, 1.0);
+        // An absurd turn is a bounded zoom, and junk never comes out as a zoom factor (the endless
+        // wheel delta last, as above).
+        let huge = egui_frame(&ctx, &mut n, false, turn(1e6)).1;
+        assert!(huge > notch_zoom && huge <= (MAX_ZOOM_STEPS * ZOOM_STEP).exp() * 1.001, "{huge}");
+        for junk in [Event::Zoom(f32::NAN), Event::Zoom(0.0), wheel(MouseWheelUnit::Page, Vec2::new(0.0, f32::INFINITY), Modifiers::COMMAND)] {
+            assert_eq!(egui_frame(&ctx, &mut n, false, vec![junk]).1, 1.0);
+        }
+    }
+
     #[test]
     fn hostile_numbers_are_ignored() {
         let mut m = Momentum::default();
diff --git a/crates/ui-egui/src/table_resize.rs b/crates/ui-egui/src/table_resize.rs
new file mode 100644
index 0000000000..81aec8771a
--- /dev/null
+++ b/crates/ui-egui/src/table_resize.rs
@@ -0,0 +1,304 @@
+//! Resizing tables with the mouse, like Word: over a column border the pointer turns into a
+//! column-resize arrow, over a row's bottom border a row-resize arrow; over a table a small
+//! handle shows past its bottom-right corner. Dragging shows a dashed preview of the new border
+//! (or outline); releasing runs `table.resizeDrag` with page coordinates, one undo step. Shift
+//! while releasing a column border changes only the column on its left. The geometry decisions
+//! are the engine's (`cmd::table_resize`).
+
+use egui::{Pos2, Rect, Stroke, Ui, pos2};
+use serde_json::json;
+use wordcraft_engine::cmd::table_resize::{self, Edge, ResizeTarget};
+use wordcraft_layout::DocLayout;
+
+use crate::WordApp;
+use crate::theme::Tokens;
+
+/// How near (screen pixels) the pointer has to be to a border to grab it.
+const REACH_PX: f32 = 4.0;
+
+/// A table border (or the handle) being dragged.
+#[derive(Clone, Debug)]
+pub(crate) struct ResizeDrag {
+    page: usize,
+    from: (f32, f32),
+    to: (f32, f32),
+    target: ResizeTarget,
+}
+
+/// Screen pixels per page point on `page`.
+fn page_scale(rects: &[Rect], layout: &DocLayout, scale: f32, page: usize) -> Option<f32> {
+    let r = rects.get(page)?;
+    let sc = layout.pages.get(page).filter(|pg| pg.w > 0.0).map_or(scale, |pg| r.width() / pg.w);
+    (sc > 0.0 && sc.is_finite()).then_some(sc)
+}
+
+fn to_screen(rects: &[Rect], layout: &DocLayout, scale: f32, page: usize, x: f32, y: f32) -> Option<Pos2> {
+    let r = rects.get(page)?;
+    let sc = page_scale(rects, layout, scale, page)?;
+    Some(pos2(r.min.x + x * sc, r.min.y + y * sc))
+}
+
+/// Whether table resizing is in reach: not while a pen, the eraser, an object drag or a text
+/// drag owns the pointer, nor while editing a header or footer from the body (or back).
+fn available(app: &WordApp) -> bool {
+    app.canvas.table_tool.is_none()
+        && app.canvas.ink.is_none()
+        && app.canvas.obj_drag.is_none()
+        && !app.canvas.drag_selecting()
+        && crate::ink::cursor(app).is_none()
+}
+
+/// The border or handle under screen point `p`, if any.
+fn target_at(app: &WordApp, layout: &DocLayout, rects: &[Rect], scale: f32, p: Pos2) -> Option<(usize, f32, f32, ResizeTarget)> {
+    let (page, x, y) = crate::canvas::page_at(rects, layout, scale, p)?;
+    let sc = page_scale(rects, layout, scale, page)?;
+    let t = table_resize::resize_target(layout, &app.session.doc, page, x, y, REACH_PX / sc)?;
+    Some((page, x, y, t))
+}
+
+/// Mouse input: a press on a border starts a drag, moving updates it, releasing applies it.
+/// `false` (nothing done) when the pointer isn't on a border, so the caret logic runs.
+pub fn pointer(app: &mut WordApp, ui: &Ui, resp: &egui::Response, rects: &[Rect], layout: &DocLayout, scale: f32) -> bool {
+    let latest = ui.input(|i| i.pointer.latest_pos());
+    if let Some(mut d) = app.canvas.table_resize.take() {
+        if let Some(p) = latest
+            && let Some(r) = rects.get(d.page)
+            && let Some(sc) = page_scale(rects, layout, scale, d.page)
+        {
+            d.to = ((p.x - r.min.x) / sc, (p.y - r.min.y) / sc);
+        }
+        if ui.input(|i| i.key_pressed(egui::Key::Escape)) {
+            return true;
+        }
+        if ui.input(|i| i.pointer.primary_down()) {
+            app.canvas.table_resize = Some(d);
+            return true;
+        }
+        // A click without a move changes nothing.
+        if (d.to.0 - d.from.0).abs() < 0.5 && (d.to.1 - d.from.1).abs() < 0.5 {
+            return true;
+        }
+        let shift = ui.input(|i| i.modifiers.shift);
+        let sc = page_scale(rects, layout, scale, d.page).unwrap_or(1.0);
+        let params = json!({
+            "page": d.page, "x": d.from.0, "y": d.from.1, "toX": d.to.0, "toY": d.to.1,
+            "shift": shift, "reach": REACH_PX / sc,
+        });
+        if let Err(e) = app.run("table.resizeDrag", params) {
+            app.status(e);
+        }
+        return true;
+    }
+    if !available(app) || !(ui.input(|i| i.pointer.primary_pressed()) && resp.contains_pointer()) {
+        return false;
+    }
+    let Some(p) = latest else { return false };
+    let Some((page, x, y, target)) = target_at(app, layout, rects, scale, p) else { return false };
+    app.canvas.table_resize = Some(ResizeDrag { page, from: (x, y), to: (x, y), target });
+    true
+}
+
+/// The resize arrow over a border or the handle, and while dragging.
+pub fn cursor(app: &WordApp, ui: &Ui, resp: &egui::Response, layout: &DocLayout, rects: &[Rect], scale: f32) {
+    let edge = match &app.canvas.table_resize {
+        Some(d) => Some(d.target.edge),
+        None if resp.hovered() && available(app) => {
+            ui.input(|i| i.pointer.latest_pos()).and_then(|p| target_at(app, layout, rects, scale, p)).map(|(_, _, _, t)| t.edge)
+        }
+        None => None,
+    };
+    let icon = match edge {
+        Some(Edge::Column(_)) => egui::CursorIcon::ResizeColumn,
+        Some(Edge::Row(_)) => egui::CursorIcon::ResizeRow,
+        Some(Edge::Corner) => egui::CursorIcon::ResizeNwSe,
+        None => return,
+    };
+    ui.ctx().set_cursor_icon(icon);
+}
+
+/// The handle past the bottom-right corner of the table under the pointer, and while dragging,
+/// a dashed preview of the new border or outline.
+pub fn paint(app: &WordApp, painter: &egui::Painter, t: &Tokens, layout: &DocLayout, rects: &[Rect], scale: f32) {
+    let s = |page: usize, x: f32, y: f32| to_screen(rects, layout, scale, page, x, y);
+    let dash = Stroke::new(1.0, t.text);
+    if let Some(d) = &app.canvas.table_resize {
+        let shift = painter.ctx().input(|i| i.modifiers.shift);
+        let tg = &d.target;
+        let plan = tg.plan(d.to.0 - d.from.0, d.to.1 - d.from.1, shift);
+        let (left, top) = (tg.left(), tg.top());
+        let right = plan.widths.as_ref().map_or(tg.right(), |w| left + w.iter().sum::<f32>());
+        let bottom = top + tg.rows.iter().map(|r| plan.heights.iter().find(|(i, _)| *i == r.row).map_or(r.bottom - r.top, |(_, h)| *h)).sum::<f32>();
+        let line = |a: Option<Pos2>, b: Option<Pos2>| {
+            if let (Some(a), Some(b)) = (a, b) {
+                painter.extend(egui::Shape::dashed_line(&[a, b], dash, 3.0, 3.0));
+            }
+        };
+        match tg.edge {
+            Edge::Column(i) => {
+                let x = left + plan.widths.as_ref().map_or(0.0, |w| w.iter().take(i).sum::<f32>());
+                line(s(d.page, x, top), s(d.page, x, tg.bottom()));
+            }
+            Edge::Row(r) => {
+                let y = tg.rows.iter().find(|x| x.row == r).map_or(top, |x| x.top) + plan.heights.first().map_or(0.0, |(_, h)| *h);
+                line(s(d.page, left, y), s(d.page, tg.right(), y));
+            }
+            Edge::Corner => {
+                if let (Some(a), Some(b)) = (s(d.page, left, top), s(d.page, right, bottom)) {
+                    let r = Rect::from_two_pos(a, b);
+                    let pts = [r.left_top(), r.right_top(), r.right_bottom(), r.left_bottom(), r.left_top()];
+                    painter.extend(egui::Shape::dashed_line(&pts, dash, 3.0, 3.0));
+                }
+            }
+        }
+        return;
+    }
+    if !available(app) {
+        return;
+    }
+    // The handle shows while the pointer is over the table (or on the handle itself).
+    let Some(p) = painter.ctx().input(|i| i.pointer.hover_pos()) else { return };
+    let Some((page, x, y)) = crate::canvas::page_at(rects, layout, scale, p) else { return };
+    let Some(sc) = page_scale(rects, layout, scale, page) else { return };
+    let Some(tg) = table_resize::table_under(layout, &app.session.doc, page, x, y, REACH_PX / sc) else { return };
+    let h = tg.handle();
+    if let (Some(a), Some(b)) = (s(page, h.x, h.y), s(page, h.right(), h.bottom())) {
+        let r = Rect::from_two_pos(a, b);
+        painter.rect_filled(r, 0.0, egui::Color32::WHITE);
+        painter.rect_stroke(r, 0.0, Stroke::new(1.0, t.text_dim), egui::StrokeKind::Inside);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    /// Screen ↔ page conversion survives a page list that doesn't match the layout.
+    #[test]
+    fn conversions_survive_missing_pages() {
+        let layout = DocLayout::default();
+        assert!(page_scale(&[], &layout, 1.0, 0).is_none());
+        assert!(to_screen(&[], &layout, 1.0, 3, 1.0, 1.0).is_none());
+        let rects = [Rect::from_min_size(pos2(10.0, 20.0), egui::vec2(100.0, 200.0))];
+        assert_eq!(page_scale(&rects, &layout, 2.0, 0), Some(2.0));
+        assert_eq!(to_screen(&rects, &layout, 2.0, 0, 5.0, 5.0), Some(pos2(20.0, 30.0)));
+        assert!(page_scale(&rects, &layout, 0.0, 0).is_none());
+    }
+
+    type H = egui_kittest::Harness<'static, WordApp>;
+
+    /// The whole window with a 2×3 table whose first cell's text is selected.
+    fn table_window() -> H {
+        let mut a = WordApp::new(wordcraft_engine::Session::new(wordcraft_doc::Document::new()), Default::default());
+        a.run("insert.table", json!({"rows": 2, "cols": 3})).unwrap();
+        a.run("text.insert", json!({"text": "Product"})).unwrap();
+        a.run("select.text", json!({"text": "Product"})).unwrap();
+        let mut h = egui_kittest::Harness::builder().with_size(egui::vec2(1440.0, 900.0)).build_ui_state(
+            |ui, app: &mut WordApp| {
+                let ctx = ui.ctx().clone();
+                app.logic(&ctx);
+                app.ui(ui);
+            },
+            a,
+        );
+        for _ in 0..6 {
+            h.step();
+        }
+        h
+    }
+
+    /// Cell (`row`, `cell`)'s rect in page points.
+    fn cell(h: &mut H, row: usize, cell: usize) -> wordcraft_geom::Rect {
+        h.state_mut().session.layout().pages[0]
+            .items
+            .iter()
+            .find_map(|it| match it {
+                wordcraft_layout::Placed::Cell { rect, row: r, cell: c, .. } if *r == row && *c == cell => Some(*rect),
+                _ => None,
+            })
+            .unwrap()
+    }
+
+    fn screen(h: &mut H, x: f32, y: f32) -> Pos2 {
+        crate::canvas::page_to_screen(h.state_mut(), 0, x, y).unwrap()
+    }
+
+    fn button(h: &H, at: Pos2, pressed: bool) {
+        h.event(egui::Event::PointerButton { pos: at, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() });
+    }
+
+    fn steps(h: &mut H, n: usize) {
+        for _ in 0..n {
+            h.step();
+        }
+    }
+
+    /// A real mouse drag of a column border: the resize arrow on hover, a preview and no change
+    /// while dragging, then one undo step on release, the selection untouched.
+    #[test]
+    fn dragging_a_column_border_with_the_mouse_is_one_undo_step() {
+        let mut h = table_window();
+        let (a, b) = (cell(&mut h, 0, 0), cell(&mut h, 0, 1));
+        let sel = h.state().session.sel.clone();
+        let depth = h.state().session.undo_depth();
+        let start = screen(&mut h, a.right(), a.y + a.h / 2.0);
+        h.event(egui::Event::PointerMoved(start));
+        steps(&mut h, 2);
+        assert_eq!(h.output().platform_output.cursor_icon, egui::CursorIcon::ResizeColumn, "the resize arrow over the border");
+        button(&h, start, true);
+        h.step();
+        // 30 page points to the right, in a few moves.
+        let end = screen(&mut h, a.right() + 30.0, a.y + a.h / 2.0);
+        for k in 1..=5 {
+            h.event(egui::Event::PointerMoved(start + (end - start) * (k as f32 / 5.0)));
+            h.step();
+        }
+        assert!(h.state().canvas.table_resize.is_some(), "a drag is in progress");
+        assert_eq!(h.state().session.undo_depth(), depth, "nothing is written while dragging");
+        assert_eq!(cell(&mut h, 0, 0), a, "the table waits for the release");
+        button(&h, end, false);
+        steps(&mut h, 3);
+        assert!(h.state().canvas.table_resize.is_none());
+        assert_eq!(h.state().session.undo_depth(), depth + 1, "one undo step for the drag");
+        let (a1, b1) = (cell(&mut h, 0, 0), cell(&mut h, 0, 1));
+        assert!((a1.w - (a.w + 30.0)).abs() < 1.0, "{a:?} → {a1:?}");
+        assert!((b1.w - (b.w - 30.0)).abs() < 1.0, "{b:?} → {b1:?}");
+        assert_eq!(h.state().session.sel, sel, "the selection is kept");
+        assert!(h.state_mut().session.undo());
+        assert_eq!(cell(&mut h, 0, 0), a);
+    }
+
+    /// Clicks inside a cell still place the caret (the border doesn't steal them), and Esc drops a
+    /// drag without changing anything.
+    #[test]
+    fn clicks_in_cells_still_move_the_caret_and_esc_cancels_a_drag() {
+        let mut h = table_window();
+        let c = cell(&mut h, 1, 1);
+        let at = screen(&mut h, c.x + c.w / 2.0, c.y + c.h / 2.0);
+        h.event(egui::Event::PointerMoved(at));
+        h.step();
+        button(&h, at, true);
+        h.step();
+        button(&h, at, false);
+        steps(&mut h, 3);
+        let focus = &h.state().session.sel.focus;
+        assert_eq!(focus.path.cell().map(|(_, r, cl)| (r, cl)), Some((1, 1)), "the caret went into the clicked cell");
+        let table = h.state().session.doc.body.iter().find_map(|b| b.as_table()).cloned();
+        let depth = h.state().session.undo_depth();
+        let a = cell(&mut h, 0, 0);
+        let start = screen(&mut h, a.x + a.w / 2.0, a.bottom());
+        h.event(egui::Event::PointerMoved(start));
+        h.step();
+        button(&h, start, true);
+        h.step();
+        let end = start + egui::vec2(0.0, 40.0);
+        h.event(egui::Event::PointerMoved(end));
+        h.step();
+        assert!(h.state().canvas.table_resize.is_some(), "the row border is being dragged");
+        h.event(egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() });
+        h.step();
+        button(&h, end, false);
+        steps(&mut h, 3);
+        assert_eq!(h.state().session.undo_depth(), depth, "Esc cancelled it");
+        assert_eq!(h.state().session.doc.body.iter().find_map(|b| b.as_table()).cloned(), table);
+    }
+}
diff --git a/crates/ui-egui/src/theme.rs b/crates/ui-egui/src/theme.rs
index 997c2d1cd5..bc23ff56b3 100644
--- a/crates/ui-egui/src/theme.rs
+++ b/crates/ui-egui/src/theme.rs
@@ -128,6 +128,72 @@ impl From<InterfaceSize> for u16 {
     }
 }
 
+/// The Animation effects setting (File › Options › Accessibility, `ui.animations`): on, off, or
+/// `System`, which follows the system's own setting as the host reports it
+/// ([`Services::animations_enabled`](crate::Services::animations_enabled): Windows' Animation
+/// effects, macOS' Reduce motion, the Linux/BSD desktop's setting, a browser's
+/// `prefers-reduced-motion`).
+/// Off: wheel notches scroll and zoom at once ([`crate::scroll`]) and nothing fades or glides
+/// ([`apply_animations`]).
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+#[serde(from = "String", into = "String")]
+pub enum Animations {
+    #[default]
+    System,
+    On,
+    Off,
+}
+
+impl Animations {
+    /// In menu order.
+    pub const ALL: [Animations; 3] = [Animations::System, Animations::On, Animations::Off];
+
+    /// The value used in `ui.json` and by the `ui.animations` command.
+    pub fn code(self) -> &'static str {
+        match self {
+            Animations::System => "system",
+            Animations::On => "on",
+            Animations::Off => "off",
+        }
+    }
+
+    pub fn from_code(code: &str) -> Option<Animations> {
+        Animations::ALL.into_iter().find(|a| a.code().eq_ignore_ascii_case(code.trim()))
+    }
+
+    /// The English label (translated with `tl!` where shown).
+    pub fn label(self) -> &'static str {
+        match self {
+            Animations::System => "Use system setting",
+            Animations::On => "On",
+            Animations::Off => "Off",
+        }
+    }
+
+    /// Whether animation effects are on, given what the system reports (`None`: it doesn't say).
+    /// `System` falls back to on when the system reports nothing.
+    pub fn enabled(self, system: Option<bool>) -> bool {
+        match self {
+            Animations::System => system.unwrap_or(true),
+            Animations::On => true,
+            Animations::Off => false,
+        }
+    }
+}
+
+/// An unknown saved value reads as the default rather than discarding the whole `ui.json`.
+impl From<String> for Animations {
+    fn from(s: String) -> Self {
+        Animations::from_code(&s).unwrap_or_default()
+    }
+}
+
+impl From<Animations> for String {
+    fn from(a: Animations) -> Self {
+        a.code().to_string()
+    }
+}
+
 /// Every colour the UI uses; widgets never hard-code colours.
 #[derive(Clone, Copy, Debug)]
 pub struct Tokens {
@@ -194,7 +260,7 @@ impl Tokens {
             accent_text: APP_INK,
             on_accent: Color32::WHITE,
             input: Color32::WHITE,
-            input_border: Color32::from_rgb(0xC7, 0xC7, 0xC7),
+            input_border: Color32::from_rgb(0x8A, 0x8A, 0x8A),
             group_label: Color32::from_rgb(0x70, 0x70, 0x70),
             ruler: Color32::from_rgb(0xFF, 0xFF, 0xFF),
             ruler_margin: Color32::from_rgb(0xD4, 0xD4, 0xD4),
@@ -232,9 +298,10 @@ impl Tokens {
             checked: Color32::from_rgb(0x2E, 0x3A, 0x66),
             accent: Color32::from_rgb(0x7A, 0x93, 0xF0),
             accent_text: Color32::from_rgb(0x9C, 0xB0, 0xF5),
-            on_accent: Color32::WHITE,
+            // Dark text on the light dark-theme accent: white on #7a93f0 is only 2.9:1 (#655).
+            on_accent: Color32::from_rgb(0x11, 0x16, 0x2E),
             input: Color32::from_rgb(0x1E, 0x1E, 0x1E),
-            input_border: Color32::from_rgb(0x58, 0x58, 0x58),
+            input_border: Color32::from_rgb(0x7A, 0x7A, 0x7A),
             group_label: Color32::from_rgb(0xA0, 0xA0, 0xA0),
             ruler: Color32::from_rgb(0x2E, 0x2E, 0x2E),
             ruler_margin: Color32::from_rgb(0x45, 0x45, 0x45),
@@ -270,12 +337,57 @@ pub fn install_fonts_for(ctx: &egui::Context, prefer_hans: bool) {
     install_fonts_with(ctx, prefer_hans, false);
 }
 
-/// [`install_fonts_for`], also adding an installed CJK font when `system_cjk` is set and no
-/// embedded face covers the need (#241). Reading that font is a large file read, so callers ask
-/// for it only when CJK text is on screen: a CJK interface language, or the language names in
-/// Options.
+/// [`install_fonts_for`], also adding an installed CJK font after the embedded faces when
+/// `system_cjk` is set and the embedded faces leave CJK characters of the interface text without
+/// a glyph (#241, #486). Reading that font is a large file read, so callers ask for it only when
+/// CJK text is on screen: a CJK interface language, or the language names in Options.
 pub fn install_fonts_with(ctx: &egui::Context, prefer_hans: bool, system_cjk: bool) {
-    ctx.set_fonts(font_definitions(prefer_hans, system_cjk));
+    install_fonts_extra(ctx, prefer_hans, system_cjk, &[]);
+}
+
+/// [`install_fonts_with`], also adding document-font `faces` as last-resort fallbacks (#565): the
+/// faces that cover the text an input method is composing.
+pub fn install_fonts_extra(ctx: &egui::Context, prefer_hans: bool, system_cjk: bool, faces: &[Arc<wordcraft_fonts::FontFace>]) {
+    let mut fonts = font_definitions(prefer_hans, system_cjk);
+    add_fallback_faces(&mut fonts, faces);
+    ctx.set_fonts(fonts);
+}
+
+/// Add `faces` after every other font of the interface families.
+pub fn add_fallback_faces(fonts: &mut FontDefinitions, faces: &[Arc<wordcraft_fonts::FontFace>]) {
+    for f in faces {
+        let name = format!("fallback {} {} {}", f.family, f.style, f.id());
+        let mut data = FontData::from_owned(f.data().to_vec());
+        data.index = f.index();
+        fonts.font_data.insert(name.clone(), Arc::new(data));
+        for fam in [FontFamily::Proportional, FontFamily::Name("medium".into()), FontFamily::Name("semibold".into())] {
+            if let Some(v) = fonts.families.get_mut(&fam) {
+                v.push(name.clone());
+            }
+        }
+    }
+}
+
+/// Document faces needed to draw `text` (the input method's composition), one for each character
+/// the interface fonts cannot draw, skipping faces in `have` (#565). Characters of the embedded
+/// interface fonts are not looked up; very large faces (system CJK collections) are left to the CJK
+/// fallback.
+pub fn faces_for_preedit(
+    text: &str,
+    have: &[Arc<wordcraft_fonts::FontFace>],
+    covered: impl Fn(char) -> bool,
+    lookup: impl Fn(char) -> Option<Arc<wordcraft_fonts::FontFace>>,
+) -> Vec<Arc<wordcraft_fonts::FontFace>> {
+    let mut out: Vec<Arc<wordcraft_fonts::FontFace>> = Vec::new();
+    for c in text.chars().filter(|c| !c.is_ascii() && !c.is_whitespace() && !covered(*c)) {
+        if have.iter().chain(&out).any(|f| f.covers(c)) {
+            continue;
+        }
+        if let Some(f) = lookup(c).filter(|f| f.data().len() <= 16 << 20 && !have.iter().chain(&out).any(|h| h.id() == f.id())) {
+            out.push(f);
+        }
+    }
+    out
 }
 
 /// The interface fonts; see [`install_fonts_with`].
@@ -311,13 +423,11 @@ pub fn font_definitions(prefer_hans: bool, system_cjk: bool) -> FontDefinitions
         // The same static bytes the document fonts use: one copy in the binary.
         add_cjk(&mut fonts, format!("{} {}", f.family, f.style), FontData::from_static(f.bytes));
     }
-    // No embedded face covers the interface language (a build without craft-fonts, or without
-    // its Chinese face, #241): an installed CJK font, so the menus don't show boxes.
+    // The embedded faces leave interface characters without a glyph (a build without craft-fonts,
+    // without its Chinese face, #241, or with faces lacking catalog characters, #486): an
+    // installed CJK font after them, so the menus don't show boxes or `?`.
     #[cfg(not(target_arch = "wasm32"))]
-    if system_cjk
-        && wordcraft_fonts::ui_needs_system_cjk(prefer_hans, &cjk)
-        && let Some(f) = system_cjk_font(prefer_hans)
-    {
+    if system_cjk && let Some(f) = system_cjk_font(prefer_hans) {
         let mut data = FontData::from_static(&f.bytes);
         data.index = f.index;
         add_cjk(&mut fonts, format!("system {}", f.family), data);
@@ -328,12 +438,29 @@ pub fn font_definitions(prefer_hans: bool, system_cjk: bool) -> FontDefinitions
     fonts
 }
 
-/// The installed CJK interface font for a Chinese (`hans`) or other interface, read once.
+/// The installed CJK interface font for a Chinese (`hans`) or other interface, chosen once:
+/// `None` when the embedded faces already cover the interface text
+/// ([`cjk_font_text`](crate::i18n::Lang::cjk_font_text)). The font is picked for the catalogs'
+/// missing characters, or for the language names when only those are missing.
 #[cfg(not(target_arch = "wasm32"))]
 fn system_cjk_font(hans: bool) -> Option<&'static wordcraft_fonts::SystemUiFont> {
     static ZH: std::sync::OnceLock<Option<wordcraft_fonts::SystemUiFont>> = std::sync::OnceLock::new();
     static OTHER: std::sync::OnceLock<Option<wordcraft_fonts::SystemUiFont>> = std::sync::OnceLock::new();
-    (if hans { &ZH } else { &OTHER }).get_or_init(|| wordcraft_fonts::system_cjk_ui_font(hans)).as_ref()
+    (if hans { &ZH } else { &OTHER })
+        .get_or_init(|| {
+            let embedded = wordcraft_fonts::ui_cjk_fonts(hans);
+            let (catalogs, names) = crate::i18n::Lang::cjk_font_text(hans);
+            let mut needed = wordcraft_fonts::ui_uncovered_cjk(&catalogs, &embedded);
+            if needed.is_empty() {
+                needed = wordcraft_fonts::ui_uncovered_cjk(&[&names], &embedded);
+                if needed.is_empty() {
+                    return None;
+                }
+            }
+            log::debug!("interface: {} CJK characters lack an embedded glyph", needed.len());
+            wordcraft_fonts::system_cjk_ui_font(hans, &needed)
+        })
+        .as_ref()
 }
 
 pub fn medium(size: f32) -> FontId {
@@ -451,6 +578,17 @@ pub fn apply(ctx: &egui::Context, appearance: Appearance) {
     });
 }
 
+/// Turn egui's own animations on or off: hover and press fades, menus, tooltips and windows fading
+/// in, sections sliding open, and the glide when a scroll area brings the caret or a list item
+/// into view. Off, each of them happens at once.
+pub fn apply_animations(ctx: &egui::Context, on: bool) {
+    let defaults = egui::Style::default();
+    ctx.all_styles_mut(|s| {
+        s.animation_time = if on { defaults.animation_time } else { 0.0 };
+        s.scroll_animation = if on { defaults.scroll_animation } else { egui::style::ScrollAnimation::none() };
+    });
+}
+
 /// egui's visuals for one of our palettes.
 fn visuals(t: &Tokens) -> Visuals {
     let mut v = if t.dark { Visuals::dark() } else { Visuals::light() };
@@ -495,6 +633,62 @@ pub fn c32(c: wordcraft_doc::Rgb) -> Color32 {
 mod tests {
     use std::collections::BTreeSet;
 
+    /// WCAG contrast ratio between two opaque colours.
+    pub(super) fn contrast(a: egui::Color32, b: egui::Color32) -> f32 {
+        let lum = |c: egui::Color32| {
+            let ch = |v: u8| {
+                let v = f32::from(v) / 255.0;
+                if v <= 0.040_45 { v / 12.92 } else { ((v + 0.055) / 1.055).powf(2.4) }
+            };
+            0.2126 * ch(c.r()) + 0.7152 * ch(c.g()) + 0.0722 * ch(c.b())
+        };
+        let (x, y) = (lum(a), lum(b));
+        (x.max(y) + 0.05) / (x.min(y) + 0.05)
+    }
+
+    /// #655: text and knobs on filled accent controls (Share, avatar, AutoSave, keytips) reach 4.5:1
+    /// on the accent and on its hover shade, in both themes.
+    #[test]
+    fn on_accent_reads_on_the_accent() {
+        for t in [super::Tokens::light(), super::Tokens::dark()] {
+            for (name, bg) in [("accent", t.accent), ("hover", t.accent_text)] {
+                let r = contrast(t.on_accent, bg);
+                assert!(r >= 4.5, "dark={}: on_accent on {name} is {r:.2}:1", t.dark);
+            }
+        }
+    }
+
+    /// #657: text field and combo outlines reach 3:1 against the field and everything it sits on.
+    #[test]
+    fn input_borders_reach_three_to_one() {
+        for t in [super::Tokens::light(), super::Tokens::dark()] {
+            for (name, bg) in [("input", t.input), ("ribbon", t.ribbon), ("panel", t.panel), ("menu", t.menu), ("title bar", t.title_bar)] {
+                let r = contrast(t.input_border, bg);
+                assert!(r >= 3.0, "dark={}: input_border on {name} is {r:.2}:1", t.dark);
+            }
+        }
+    }
+
+    /// #565: the composition of an input method (Bangla through ibus) drew as boxes because only the
+    /// interface fonts were used. Faces found for the uncovered characters are added as fallbacks,
+    /// once, and not for characters the interface fonts draw.
+    #[test]
+    fn preedit_gets_document_fallback_faces() {
+        let face = wordcraft_fonts::FontDb::global().face("Source Sans 3", "Regular");
+        let lookup = |_: char| Some(face.clone());
+        let bangla = "\u{0986}\u{09AE}\u{09BF}";
+        let got = super::faces_for_preedit(bangla, &[], |_| false, lookup);
+        assert_eq!(got.len(), 1, "one face, not one per character");
+        assert!(super::faces_for_preedit(bangla, &got, |_| false, lookup).is_empty(), "already added");
+        assert!(super::faces_for_preedit(bangla, &[], |_| true, lookup).is_empty(), "the interface fonts draw it");
+        assert!(super::faces_for_preedit("abc", &[], |_| false, lookup).is_empty(), "ASCII never needs one");
+        let mut defs = super::font_definitions(false, false);
+        let before = defs.font_data.len();
+        super::add_fallback_faces(&mut defs, &got);
+        assert_eq!(defs.font_data.len(), before + 1);
+        assert!(defs.families[&egui::FontFamily::Proportional].last().is_some_and(|n| n.starts_with("fallback ")));
+    }
+
     /// Symbols written as text in the interface code must exist in the interface fonts (Inter and
     /// egui's emoji fallbacks); a missing glyph draws as an empty box, as the panes' "✕" close
     /// button once did. Letters are the catalogs' business (see the i18n font tests).
diff --git a/crates/ui-egui/src/widgets.rs b/crates/ui-egui/src/widgets.rs
index 3602e5acd5..4df392c8c7 100644
--- a/crates/ui-egui/src/widgets.rs
+++ b/crates/ui-egui/src/widgets.rs
@@ -89,7 +89,7 @@ pub fn enabled(app: &WordApp, id: &str) -> bool {
     }
 }
 
-fn bg(ui: &Ui, r: Rect, resp: &Response, checked: bool, t: &Tokens) {
+pub(crate) fn bg(ui: &Ui, r: Rect, resp: &Response, checked: bool, t: &Tokens) {
     let fill = if resp.is_pointer_button_down_on() {
         t.pressed
     } else if checked {
@@ -399,7 +399,7 @@ pub fn color_grid(ui: &mut Ui, theme: &[wordcraft_doc::Rgb]) -> Option<String> {
     picked
 }
 
-fn swatch(ui: &mut Ui, c: wordcraft_doc::Rgb) -> bool {
+pub(crate) fn swatch(ui: &mut Ui, c: wordcraft_doc::Rgb) -> bool {
     let (r, resp) = ui.allocate_exact_size(vec2(15.0, 15.0), Sense::click());
     ui.painter().rect_filled(r, 0.0, Color32::from_rgb(c.0, c.1, c.2));
     let t = Tokens::get(ui.ctx());
@@ -425,7 +425,12 @@ pub fn combo(
     combo_impl(ui, id, width, current, items, preview, false)
 }
 
+/// What [`font_combo`] returns when its list's last entry, Add Font…, is chosen (#582): the
+/// caller runs `font.add`, which shows a file picker. Not a family name anyone can type.
+pub const ADD_FONT: &str = "\u{1}font.add";
+
 /// The font box: a [`combo`] where typing lists the matching families under the field (#359).
+/// Its list ends with Add Font… ([`ADD_FONT`]).
 /// Up/Down move the highlight, Enter or a click applies the highlighted family ("arial" applies
 /// "Arial"), Escape restores the current font. Text matching no family is applied as typed, as
 /// Word allows fonts that are not installed.
@@ -559,12 +564,20 @@ fn combo_impl(
         }
         let (ar, aresp) = ui.allocate_exact_size(vec2(16.0, resp.rect.height()), Sense::click());
         ui.painter().rect(ar, 0.0, if aresp.hovered() { t.hover } else { t.input }, Stroke::new(1.0, t.input_border), egui::StrokeKind::Inside);
-        icons::paint(ui.painter(), Rect::from_center_size(ar.center(), vec2(9.0, 9.0)), "dropdown", t.icon, t.accent);
-        egui::Popup::menu(&aresp).show(|ui| {
+        icons::paint(ui.painter(), Rect::from_center_size(ar.center(), vec2(10.0, 10.0)), "dropdown", t.icon, t.accent);
+        // The list drops from the box's left edge, as in Word, not from the arrow (#535).
+        egui::Popup::menu(&aresp).anchor(resp.rect.union(ar)).show(|ui| {
             if let Some(v) = combo_list(ui, width, current, items, preview) {
                 out = Some(v);
                 ui.close();
             }
+            if search {
+                ui.separator();
+                if ui.button(tl!("Add Font…")).clicked() {
+                    out = Some(ADD_FONT.to_string());
+                    ui.close();
+                }
+            }
         });
         if s.open && !s.matches.is_empty() {
             let matches = s.matches.clone();
@@ -672,7 +685,8 @@ fn list_rows<'a>(
 /// How a drawn button looks this frame. Hover fades in over egui's animation time and the
 /// pressed state blends in while the pointer is down, as on egui's own buttons. Framed buttons
 /// take egui's widget visuals (fill, stroke, text colour, expansion) so they match `ui.button`;
-/// frameless ones take the ribbon's hover/pressed tokens, like [`small`] and [`big`].
+/// frameless ones take the ribbon's hover/pressed tokens, like [`small`] and [`big`]. With
+/// animation effects off (egui's animation time is zero) both states show at once.
 pub struct DrawnState {
     pub fill: Color32,
     pub stroke: Stroke,
@@ -683,7 +697,7 @@ pub struct DrawnState {
 pub fn drawn_state(ui: &Ui, resp: &Response, framed: bool) -> DrawnState {
     let pressed = resp.is_pointer_button_down_on();
     let h = ui.ctx().animate_bool_responsive(resp.id.with("hover"), resp.hovered() || pressed);
-    let p = ui.ctx().animate_bool_with_time(resp.id.with("press"), pressed, 0.06);
+    let p = ui.ctx().animate_bool_with_time(resp.id.with("press"), pressed, ui.style().animation_time.min(0.06));
     if framed {
         let w = &ui.visuals().widgets;
         let mix = |a: Color32, b: Color32, c: Color32| a.lerp_to_gamma(b, h).lerp_to_gamma(c, p);
diff --git a/crates/ui-egui/src/wordart_menus.rs b/crates/ui-egui/src/wordart_menus.rs
new file mode 100644
index 0000000000..a9f7fac623
--- /dev/null
+++ b/crates/ui-egui/src/wordart_menus.rs
@@ -0,0 +1,222 @@
+//! WordArt menus: the style gallery (Insert › WordArt, Home › Text Effects, Shape Format ›
+//! WordArt Styles), Text Fill, Text Outline and Text Effects (Shadow, Glow, Reflection,
+//! Transform). Previews are drawn in code from our own styles and the warp geometry itself.
+
+use egui::{Align2, Color32, Pos2, Rect, Sense, Stroke, Ui, pos2, vec2};
+use serde_json::json;
+use wordcraft_doc::Rgb;
+use wordcraft_doc::wordart::{ART_STYLES, DRAWN_WARPS, TextFill, TextWarp, art_style};
+
+use crate::WordApp;
+use crate::ribbon::mi;
+use crate::theme::{Tokens, semibold};
+use crate::widgets::color_grid;
+
+fn c32(c: Rgb) -> Color32 {
+    Color32::from_rgb(c.0, c.1, c.2)
+}
+
+/// A clickable preview cell `w` × `h`; true when clicked.
+fn cell(ui: &mut Ui, w: f32, h: f32, tip: &str, paint: impl FnOnce(&egui::Painter, Rect)) -> bool {
+    let t = Tokens::get(ui.ctx());
+    let (r, resp) = ui.allocate_exact_size(vec2(w, h), Sense::click());
+    let bg = if resp.hovered() { t.hover } else { t.input };
+    ui.painter().rect_filled(r, 3.0, bg);
+    ui.painter().rect_stroke(r, 3.0, Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
+    paint(ui.painter(), r.shrink(3.0));
+    resp.on_hover_text(crate::tl!(tip)).clicked()
+}
+
+/// A letter "A" drawn in WordArt style `id` (its fill, outline, shadow and glow, roughly).
+fn paint_style(p: &egui::Painter, r: Rect, id: &str, theme: &[Rgb]) {
+    let Some(fx) = art_style(id, theme) else { return };
+    let font = semibold(r.height() * 0.8);
+    let at = r.center();
+    let text = |dx: f32, dy: f32, c: Color32| {
+        p.text(at + vec2(dx, dy), Align2::CENTER_CENTER, "A", font.clone(), c);
+    };
+    if let Some(g) = fx.glow {
+        let c = c32(g.color).gamma_multiply(0.35);
+        for (dx, dy) in [(-2.0, 0.0), (2.0, 0.0), (0.0, -2.0), (0.0, 2.0), (-1.5, -1.5), (1.5, 1.5), (-1.5, 1.5), (1.5, -1.5)] {
+            text(dx, dy, c);
+        }
+    }
+    if fx.shadow.is_some() {
+        text(1.5, 1.5, Color32::from_black_alpha(110));
+    }
+    if fx.reflection.is_some() {
+        p.rect_filled(
+            Rect::from_min_max(pos2(r.center().x - r.width() * 0.25, r.max.y - 3.0), pos2(r.center().x + r.width() * 0.25, r.max.y)),
+            1.0,
+            Color32::from_gray(190),
+        );
+    }
+    if let Some(o) = fx.outline.and_then(|o| o.color) {
+        for (dx, dy) in [(-0.8, 0.0), (0.8, 0.0), (0.0, -0.8), (0.0, 0.8)] {
+            text(dx, dy, c32(o));
+        }
+    }
+    match &fx.fill {
+        Some(TextFill::None) => text(0.0, 0.0, Tokens::get(p.ctx()).input),
+        Some(f) => {
+            let c = f.main_color().map_or(Color32::BLACK, c32);
+            text(0.0, 0.0, c);
+            if let TextFill::Gradient { stops, .. } = f
+                && let Some(first) = stops.first()
+            {
+                // The gradient's first colour over the top half.
+                let top = Rect::from_min_max(r.min, pos2(r.max.x, r.center().y));
+                p.with_clip_rect(top).text(at, Align2::CENTER_CENTER, "A", font.clone(), c32(first.color));
+            }
+        }
+        None => text(0.0, 0.0, Color32::BLACK),
+    }
+}
+
+/// Our WordArt styles as a grid; a click runs `cmd` with `{"style": id}`.
+pub fn style_gallery(ui: &mut Ui, app: &mut WordApp, cmd: &str) {
+    let theme = app.session.doc.settings.theme_colors.clone();
+    egui::Grid::new(("wordart-styles", cmd)).spacing(vec2(4.0, 4.0)).show(ui, |ui| {
+        for (i, (id, label)) in ART_STYLES.iter().enumerate() {
+            if cell(ui, 40.0, 36.0, label, |p, r| paint_style(p, r, id, &theme)) {
+                let _ = app.run(cmd, json!({"style": id}));
+                ui.close();
+            }
+            if i % 4 == 3 {
+                ui.end_row();
+            }
+        }
+    });
+}
+
+/// Text Fill: automatic (the text's colour), a colour, no fill (hollow), or a gradient of
+/// theme colours.
+pub fn fill_menu(ui: &mut Ui, app: &mut WordApp, theme: &[Rgb]) {
+    mi(ui, app, "Automatic", "format.textEffects", json!({"fill": null}));
+    mi(ui, app, "No Fill", "format.textEffects", json!({"fill": "none"}));
+    if let Some(hex) = color_grid(ui, theme) {
+        let _ = app.run("format.textEffects", json!({"fill": hex}));
+        ui.close();
+    }
+    ui.add_space(4.0);
+    let slot = |i: usize| theme.get(i).copied().unwrap_or(Rgb::BLACK);
+    ui.horizontal(|ui| {
+        for (a, b) in [(slot(4), slot(7)), (slot(5), slot(8)), (slot(1), slot(4)), (slot(2), slot(9))] {
+            let clicked = cell(ui, 40.0, 18.0, "Text Fill", |p, r| {
+                let n = 12;
+                for k in 0..n {
+                    let f = k as f32 / (n - 1) as f32;
+                    let mix = |x: u8, y: u8| (x as f32 + (y as f32 - x as f32) * f) as u8;
+                    let c = Color32::from_rgb(mix(a.0, b.0), mix(a.1, b.1), mix(a.2, b.2));
+                    let y0 = r.min.y + r.height() * k as f32 / n as f32;
+                    p.rect_filled(Rect::from_min_max(pos2(r.min.x, y0), pos2(r.max.x, y0 + r.height() / n as f32 + 0.5)), 0.0, c);
+                }
+            });
+            if clicked {
+                let _ = app.run("format.textEffects", json!({"fill": {"gradient": [a.hex(), b.hex()], "angle": 90}}));
+                ui.close();
+            }
+        }
+    });
+}
+
+/// Text Outline: automatic (none set), no outline, a colour, a weight.
+pub fn outline_menu(ui: &mut Ui, app: &mut WordApp, theme: &[Rgb], current: Option<(Rgb, f32)>) {
+    mi(ui, app, "Automatic", "format.textEffects", json!({"outline": null}));
+    mi(ui, app, "No Outline", "format.textEffects", json!({"outline": "none"}));
+    let width = current.map_or(0.75, |c| c.1);
+    if let Some(hex) = color_grid(ui, theme) {
+        let _ = app.run("format.textEffects", json!({"outline": {"color": hex, "width": width}}));
+        ui.close();
+    }
+    ui.separator();
+    ui.menu_button(crate::tl!("Weight"), |ui| {
+        let color = current.map_or(Rgb::BLACK, |c| c.0).hex();
+        for w in [0.25, 0.5, 0.75, 1.0, 1.5, 2.25, 3.0] {
+            mi(ui, app, &format!("{w} pt"), "format.textEffects", json!({"outline": {"color": color, "width": w}}));
+        }
+    });
+}
+
+/// A warp's preview: its top, middle and bottom lines and a few verticals, bent as the text is.
+fn paint_warp(p: &egui::Painter, r: Rect, preset: &str, c: Color32) {
+    let Some(tw) = TextWarp::new(preset) else { return };
+    let frame = wordcraft_geom::Rect::new(r.min.x, r.min.y, r.width(), r.height());
+    let Some(w) = wordcraft_layout::wordart::Warp::new(&tw, frame, 0.3) else { return };
+    let pt = |u: f32, v: f32| {
+        let (x, y) = w.map(u, v);
+        Pos2::new(x, y)
+    };
+    for v in [0.0, 1.0] {
+        p.add(egui::Shape::line((0..=24).map(|i| pt(i as f32 / 24.0, v)).collect(), Stroke::new(1.0, c)));
+    }
+    p.add(egui::Shape::line((0..=24).map(|i| pt(i as f32 / 24.0, 0.5)).collect(), Stroke::new(1.0, c.gamma_multiply(0.5))));
+    for u in [0.0, 0.25, 0.5, 0.75, 1.0] {
+        p.line_segment([pt(u, 0.0), pt(u, 1.0)], Stroke::new(1.0, c.gamma_multiply(0.6)));
+    }
+}
+
+/// Text Effects: Shadow, Glow and Reflection (and Transform, for a shape's text).
+pub fn effects_menu(ui: &mut Ui, app: &mut WordApp, theme: &[Rgb], transform: bool) {
+    ui.menu_button(crate::tl!("Shadow"), |ui| {
+        mi(ui, app, "No Shadow", "format.textEffects", json!({"shadow": null}));
+        ui.separator();
+        for (id, label) in wordcraft_doc::effects::SHADOW_PRESETS {
+            mi(ui, app, label, "format.textEffects", json!({"shadow": id}));
+        }
+    });
+    ui.menu_button(crate::tl!("Glow"), |ui| {
+        mi(ui, app, "No Glow", "format.textEffects", json!({"glow": null}));
+        ui.separator();
+        for size in [3.0, 5.0, 8.0, 11.0] {
+            mi(ui, app, &format!("{size} pt"), "format.textEffects", json!({"glow": size}));
+        }
+        ui.separator();
+        ui.menu_button(crate::tl!("Glow Colors"), |ui| {
+            if let Some(hex) = color_grid(ui, theme) {
+                let _ = app.run("format.textEffects", json!({"glow": {"color": hex, "size": 5.0}}));
+                ui.close();
+            }
+        });
+    });
+    ui.menu_button(crate::tl!("Reflection"), |ui| {
+        mi(ui, app, "No Reflection", "format.textEffects", json!({"reflection": null}));
+        ui.separator();
+        for size in [25.0, 50.0, 90.0] {
+            mi(ui, app, &format!("{size:.0}%"), "format.textEffects", json!({"reflection": {"size": size}}));
+        }
+    });
+    if transform {
+        ui.menu_button(crate::tl!("Transform"), |ui| transform_menu(ui, app));
+    }
+}
+
+/// Text Effects › Transform: the warps WordCraft bends text along, as previews.
+pub fn transform_menu(ui: &mut Ui, app: &mut WordApp) {
+    let t = Tokens::get(ui.ctx());
+    mi(ui, app, "No Transform", "wordArt.transform", json!({"preset": "none"}));
+    ui.add_space(4.0);
+    egui::Grid::new("wordart-warps").spacing(vec2(4.0, 4.0)).show(ui, |ui| {
+        for (i, (id, label)) in DRAWN_WARPS.iter().enumerate() {
+            if cell(ui, 46.0, 32.0, label, |p, r| paint_warp(p, r.shrink(2.0), id, t.accent)) {
+                let _ = app.run("wordArt.transform", json!({"preset": id}));
+                ui.close();
+            }
+            if i % 4 == 3 {
+                ui.end_row();
+            }
+        }
+    });
+}
+
+/// The selected shape's text outline (colour, width), for the Weight menu.
+pub fn current_outline(app: &WordApp) -> Option<(Rgb, f32)> {
+    let story = match wordcraft_engine::cmd::objects::object_selection(&app.session) {
+        Some((_, wordcraft_doc::InlineObject::Shape { story: Some(id), .. })) => wordcraft_doc::StoryRef::Part(*id),
+        _ => app.session.sel.focus.story,
+    };
+    let start = app.session.doc.start_of(story);
+    let para = app.session.doc.para_at(&start)?;
+    let fx = para.props_at(0).text_effects.as_deref()?;
+    fx.outline.and_then(|o| o.color.map(|c| (c, o.width)))
+}
diff --git a/crates/ui-egui/src/zotero.rs b/crates/ui-egui/src/zotero.rs
index a8dc1a4ef7..0437df5739 100644
--- a/crates/ui-egui/src/zotero.rs
+++ b/crates/ui-egui/src/zotero.rs
@@ -38,6 +38,8 @@ pub struct ZoteroLink {
     alert: Option<Alert>,
     /// The command in flight.
     pub busy: Option<Command>,
+    /// The document the command in flight started in; its calls are refused once another is open.
+    document: u64,
     /// How the last command ended.
     pub last: Option<Value>,
     /// Zotero's calls in the command in flight (logged when it ends).
@@ -96,6 +98,7 @@ fn start(app: &mut WordApp, cmd: Command, ctx: Option<egui::Context>) -> Result<
     if let Some(b) = app.zotero.busy {
         return Err(format!("Zotero is still working on {}; finish in Zotero's window first", b.wire_name()));
     }
+    let document = app.session.document_id();
     let (call_tx, call_rx) = channel::<Pending>();
     let (done_tx, done_rx) = channel();
     let wake = ctx.clone();
@@ -123,6 +126,7 @@ fn start(app: &mut WordApp, cmd: Command, ctx: Option<egui::Context>) -> Result<
     z.calls = Some(call_rx);
     z.done = Some(done_rx);
     z.busy = Some(cmd);
+    z.document = document;
     log::info!("Zotero: {} started", cmd.wire_name());
     app.status(tl!("Waiting for Zotero…"));
     Ok(json!({"started": cmd.wire_name()}))
@@ -156,7 +160,7 @@ pub fn poll(app: &mut WordApp, ctx: &egui::Context) {
     // One alert at a time: Zotero sends nothing else while it waits for the answer.
     while app.zotero.alert.is_none() {
         let Some(p) = app.zotero.calls.as_ref().and_then(|rx| rx.try_recv().ok()) else { break };
-        if p.call.method == "Document_displayAlert" {
+        if p.call.method == "Document_displayAlert" && app.session.document_id() == app.zotero.document {
             let text = p.call.args.get(1).and_then(Value::as_str).unwrap_or("").to_string();
             let buttons = p.call.args.get(3).and_then(Value::as_i64).unwrap_or(0);
             app.zotero.methods.push(p.call.method.clone());
@@ -164,6 +168,11 @@ pub fn poll(app: &mut WordApp, ctx: &egui::Context) {
             continue;
         }
         app.zotero.methods.push(p.call.method.clone());
+        if app.session.document_id() != app.zotero.document {
+            // New or Open replaced the document this command started in: its edits must not land in the new one.
+            let _ = p.reply.send(Err("WordCraft replaced the document this command started in".into()));
+            continue;
+        }
         let rev = app.session.rev();
         let mut host = AppHost { ctx };
         let r = app.zotero.bridge.handle(&mut app.session, &mut host, &p.call);
@@ -313,6 +322,27 @@ mod tests {
         assert_eq!(app.session.doc.plain_text(StoryRef::Body), "Cite: ");
     }
 
+    #[test]
+    fn a_pending_citation_does_not_insert_into_a_replacement_document() {
+        let (addr, server) = fake_zotero(vec![
+            json!(["Application_getActiveDocument", [3]]),
+            json!(["Document_insertField", [1, "ReferenceMark", 0]]),
+            json!(["Field_setCode", [1, 1, "ITEM CSL_CITATION {}"]]),
+            json!(["Field_setText", [1, 1, "(Sample, 2020)", false]]),
+            json!(["Document_complete", [1]]),
+        ]);
+        let mut app = WordApp::new(Session::new(Document::new()), Services::default());
+        app.zotero.options.addr = addr;
+        let ctx = egui::Context::default();
+        app.ctx = Some(ctx.clone());
+        app.run("ui.zotero.addEditCitation", json!({})).unwrap();
+        app.run("file.new", json!({"template": "blank"})).unwrap();
+        pump(&mut app, &ctx, |a| a.zotero.busy.is_none());
+        server.join().unwrap();
+        assert_eq!(app.session.doc.plain_text(StoryRef::Body), "");
+        assert!(!app.session.can_undo(), "the old command left no undo step in the new document");
+    }
+
     #[test]
     fn no_zotero_is_a_clear_error() {
         let free = TcpListener::bind("127.0.0.1:0").unwrap().local_addr().unwrap();
diff --git a/crates/zotero/src/bridge.rs b/crates/zotero/src/bridge.rs
index c95e67abe4..b5d00bba29 100644
--- a/crates/zotero/src/bridge.rs
+++ b/crates/zotero/src/bridge.rs
@@ -568,6 +568,10 @@ fn remove_empty_note(s: &mut Session, f: &ZField) -> Option<Pos> {
     for b in blocks {
         if let Some(p) = b.as_para() {
             rest.push_str(&p.text);
+            // A picture, shape, equation... is content too, even though it has no text.
+            if !p.objects.iter().all(|o| o.is_marker() || matches!(o, InlineObject::NoteRef { .. })) {
+                return None;
+            }
         }
     }
     if rest.chars().any(|c| c != OBJ && !c.is_whitespace()) {
diff --git a/crates/zotero/src/tests.rs b/crates/zotero/src/tests.rs
index a4a365ddb3..4a8d5810e4 100644
--- a/crates/zotero/src/tests.rs
+++ b/crates/zotero/src/tests.rs
@@ -512,6 +512,22 @@ fn a_note_with_other_text_stays_when_its_citation_leaves() {
     assert!(z.call("Document_convert", json!([1, [999], [], [1], 1])).is_err());
 }
 
+#[test]
+fn a_note_with_a_picture_stays_when_its_citation_leaves() {
+    let mut z = Z::new("Text.", 5);
+    z.begin();
+    let a = z.cite(1, "Doe, Title.");
+    let pid = *z.s.doc.parts.keys().next().unwrap();
+    let p = z.s.doc.para_mut(StoryRef::Part(pid), &Path::top(0)).unwrap();
+    let n = p.len();
+    let image = InlineObject::Image { media: "m".into(), w: 1.0, h: 1.0, alt: String::new(), float: Default::default(), crop: [0.0; 4], ole: None };
+    p.insert_object(n, image, &Default::default()).unwrap();
+    z.ok("Field_convert", json!([1, a, "ReferenceMark", 0]));
+    assert_eq!(z.s.doc.parts.len(), 1);
+    assert!(z.s.doc.para(StoryRef::Part(pid), &Path::top(0)).unwrap().objects.iter().any(|o| matches!(o, InlineObject::Image { .. })));
+    assert!(z.text().ends_with("Doe, Title."));
+}
+
 /// Zotero reads a new bibliography field back before filling it, and unlinks it when it is
 /// empty (it takes that for a bibliography the user deleted). Seen with Zotero 10: Add/Edit
 /// Bibliography did nothing.
diff --git a/docs/brand/LICENSE-brand.txt b/docs/brand/LICENSE-brand.txt
index 6319613cf0..3611943c20 100644
--- a/docs/brand/LICENSE-brand.txt
+++ b/docs/brand/LICENSE-brand.txt
@@ -2,7 +2,7 @@ ArtCraft brand assets: license
 
 The ArtCraft name, wordmark and mark (the "ArtCraft Marks"), including every file in this
 directory in every color, size and format, are owned by the ArtCraft Team. They are trademarks
-and are NOT open source. They are not covered by DesignCraft's MIT OR Apache-2.0 license, and nothing in
+and are NOT open source. They are not covered by WordCraft's MIT OR Apache-2.0 license, and nothing in
 that license, in NOTICE or in any other file of this repository grants any right to them.
 
 Permission
@@ -11,7 +11,7 @@ The ArtCraft Team grants a limited, non-exclusive, non-transferable, revocable,
 permission to use the ArtCraft Marks only:
 
   1. as part of copies of this repository; and
-  2. within DesignCraft itself, its documentation and its official builds, to identify DesignCraft as made
+  2. within WordCraft itself, its documentation and its official builds, to identify WordCraft as made
      by the ArtCraft team and community and to link to getartcraft.com and its community.
 
 Conditions
@@ -21,17 +21,17 @@ The permission holds only while every one of these is true:
   - The marks are used exactly as supplied in this directory. Do not redraw, recolor, crop,
     stretch, rotate, animate, outline or add effects to them, extract parts of them, or combine
     them with any other name, mark or artwork.
-  - They are used only in the context of DesignCraft, and only to say that the ArtCraft team makes it.
+  - They are used only in the context of WordCraft, and only to say that the ArtCraft team makes it.
     They must never suggest that the ArtCraft Team made, sponsors, endorses, certifies or supports
     any other product, service, fork, modified version, plug-in, organization or person.
   - Neither the marks nor the ArtCraft name appear in the name, logo, icon, domain, social media
-    handle, app-store listing, advertising or marketing of anything other than DesignCraft.
+    handle, app-store listing, advertising or marketing of anything other than WordCraft.
 
 Forks and modified versions
 
-If you distribute or publish a modified version of DesignCraft, or any work derived from it, you must
+If you distribute or publish a modified version of WordCraft, or any work derived from it, you must
 remove the ArtCraft Marks from it (or replace them with your own) and must not call it ArtCraft or
-present it as an ArtCraft product. You may say, in plain text, that your work is based on DesignCraft by
+present it as an ArtCraft product. You may say, in plain text, that your work is based on WordCraft by
 the ArtCraft team. A fork kept only to propose changes back to this repository may keep the marks
 unchanged.
 
diff --git a/docs/control-protocol.md b/docs/control-protocol.md
index d19df87e19..927182299f 100644
--- a/docs/control-protocol.md
+++ b/docs/control-protocol.md
@@ -50,7 +50,7 @@ and set `WORDCRAFT_CONTROL_KEY` to that app's key.
 
 | Method | Params | Result |
 |---|---|---|
-| `engine.execute` | `command`, `params` | the command's result (any id from `engine.commands`, including UI commands `ui.tab`, `ui.dialog`, `ui.backstage`, `ui.zotero.*` (see `docs/zotero.md`), `ui.language` (`{"value": "auto"|"en"|"zh-hans"|"zh-hant"|"ja"|"pt-br"|"es"|"uk"|"sr"|"sr-latn"|"et"|"tr"|"ru"|"pl"}`), `ui.theme` (`{"value": "system"|"light"|"dark"}`; `system` follows the OS appearance, light when it reports none), `ui.interfaceSize` (`{"percent": 80–200}`, clamped; no value reads it; scales the interface on top of the system display scale, document zoom stays `view.zoom`)…) |
+| `engine.execute` | `command`, `params` | the command's result (any id from `engine.commands`, including UI commands `ui.tab`, `ui.dialog`, `ui.backstage`, `ui.zotero.*` (see `docs/zotero.md`), `ui.language` (`{"value": "auto"|"en"|"zh-hans"|"zh-hant"|"ja"|"pt-br"|"es"|"uk"|"sr"|"sr-latn"|"et"|"tr"|"ru"|"pl"}`), `ui.theme` (`{"value": "system"|"light"|"dark"}`; `system` follows the OS appearance, light when it reports none), `ui.interfaceSize` (`{"percent": 80–200}`, clamped; no value reads it; scales the interface on top of the system display scale, document zoom stays `view.zoom`), `ui.animations` (`{"value": "system"|"on"|"off"}`; no value reads it; `system` follows the system's animation setting, which the desktop app reads on Windows, macOS, Linux and the BSDs and the web app from `prefers-reduced-motion`, and means on where the system doesn't say; the result's `enabled` is what the setting comes to and `system` what the system reports, `null` when it doesn't say), `ui.fileBrowser` (desktop: `{"purpose": "document"|"picture"|"recipients"|"save"}` opens WordCraft's own file browser, for when the system file dialog doesn't show up, #576), `ui.caretAnimation` (`{"value": true|false}`; no value reads it; off, the caret jumps and blinks on and off instead of gliding and fading)…) |
 | `engine.commands` | — | every command: id, label, location, shortcut, params, enabled |
 | `document.inspect` | `text?` | blocks (text, style, runs, lists, tables), parts, sections, selection, pages |
 | `ui.inspect` | — | UI state, view, dialog, window size, page rects on screen, caret, comment balloons (`balloons`: id + screen rect; `balloon`: the selected one), perf |
@@ -60,8 +60,8 @@ and set `WORDCRAFT_CONTROL_KEY` to that app's key.
 | `ui.press` / `ui.release` | `x`,`y`, modifiers | primary button down / up there (with `ui.move` between: a drag you can screenshot halfway) |
 | `ui.key` | `key` (`B`, `Enter`, `Left`…), `shift?`, `alt?`, `cmd?` | key press through egui (shortcuts apply) |
 | `ui.text` | `text` | typed text through egui |
-| `ui.screenshot` | `path?` | PNG of the window |
-| `ui.render` | `path`, `page?` (1-based), `scale?` | PNG of a page, rendered by the engine |
+| `ui.screenshot` | `path?` | PNG of the window: written to `path`, or without one returned as base64 `png` in the reply |
+| `ui.render` | `path?`, `page?` (1-based), `scale?` | PNG of a page, rendered by the engine: written to `path`, or without one returned as base64 `png` in the reply (never a fixed name in the shared temporary folder) |
 | `ui.parity` | — | feature-catalog parity |
 | `ui.resize` / `ui.focus` / `app.quit` | | window control |
 
diff --git a/docs/file-format-parity.md b/docs/file-format-parity.md
index 53e89e56e4..7493c4126a 100644
--- a/docs/file-format-parity.md
+++ b/docs/file-format-parity.md
@@ -1,13 +1,13 @@
 # File-format parity with Microsoft Word
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** trivial (import/export fixes for TXT, RTF, ODT, HTML and LaTeX, #433–#440; previously major: first version; every format Word reads or writes, measured from the readers and writers on origin/main) · **Target:** Microsoft Word (Microsoft 365) for Mac 16.113.4, plus Word for Windows' extra formats
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-12 · **Change:** trivial (native save temporary-file ownership and failure protection; previously trivial: Print Markup: comments in PDF/print/copies, #589; previously trivial: SmartArt written from WordCraft's model, #497; previously trivial: import/export fixes for TXT, RTF, ODT, HTML and LaTeX, #433–#440; previously major: first version; every format Word reads or writes, measured from the readers and writers on origin/main) · **Target:** Microsoft Word (Microsoft 365) for Mac 16.113.4, plus Word for Windows' extra formats
 
 Every format Word opens or saves, what WordCraft does with it, and how it's tested. Fidelity is the
 share of a typical real-world file's content and formatting that survives (read: shows correctly;
 write: Word opens it showing the same). Summary in [`target-app-parity.md`](target-app-parity.md);
 the work items are in [`gaps.md`](gaps.md).
 
-**Dimension: ~60% (estimated), 185–300 h to full** (the sum of the rows below). The weighted table
+**Dimension: ~60% (estimated), 179–290 h to full** (the sum of the rows below). The weighted table
 gives ~64%; we discount it to ~60% because DOCX fidelity has never been checked on real-world
 files. DOCX dominates the weight: a Word user sends and receives .docx; everything else is
 occasional.
@@ -23,15 +23,15 @@ Weights are the share of a Word user's file traffic (estimate). Read/write: ✅
 | `.docx` Strict Open XML | 1% | R/W | ✅ (namespace mapping in `xml.rs`) | ❌ | ~60% | 2–4 | one fixture | Writing Strict is rare |
 | `.docm` / `.dotx` / `.dotm` | 3% | R/W | ✅ | ✅ | ~65% | incl. above | `macro_packages.rs` | Macros and signatures kept on save (#172); macros never run |
 | `.doc` Word 97-2003 (and `.dot`) | 8% | R/W | 🟡 | ❌ | ~55% | 25–40 | `crates/docbin/src/tests.rs` (56) | Spec-based reader ([MS-DOC]): text, formatting, styles, sections, headers/footers, tables, lists, notes, fields, bookmarks, pictures. Metafile (WMF/EMF) pictures, Word 6/95 files and encrypted files are refused or dropped. No writer |
-| PDF export | 8% | W | — | ✅ | ~80% | 6–10 | `crates/pdf/src/tests.rs` | krilla: embedded subsets, selectable text incl. field results (#133), links, outline, tagging. Fonts it can't subset become outlines (#132). No PDF/A option, no "best for printing/online" choice |
+| PDF export | 8% | W | — | ✅ | ~80% | 6–10 | `crates/pdf/src/tests.rs` | krilla: embedded subsets, selectable text incl. field results (#133), links, outline, tagging. Fonts it can't subset become outlines (#132). Print Markup (#589): comments in balloons beside each page (scaled to its paper) and tracked changes; HTML/Markdown/text copies end with a comment list. No PDF/A option, no "best for printing/online" choice |
 | PDF open (PDF Reflow, Word for Windows) | 1% | R | ❌ | — | 0% | 30–50 | — | Converting a PDF into an editable document. A sibling app (PdfCraft) may supply the parser |
 | `.rtf` Rich Text Format | 3% | R/W | 🟡 | 🟡 | ~50% | 10–15 | `crates/formats/src/tests.rs` | ~1,500 lines: text, character/paragraph formatting, styles, lists, tables, pictures (`\shppict`, #154), fields, bookmarks. Thin: comments, notes, revisions, sections, RTL |
 | `.odt` OpenDocument Text | 2% | R/W | 🟡 | 🟡 | ~50% | 8–12 | `crates/formats/src/tests.rs` | Styles, lists (#87), tables, pictures, headers/footers, page breaks (#86). No footnotes, comments, tracked changes, fields or RTL |
-| `.txt` Plain text | 2% | R/W | ✅ | ✅ | ~95% | 1–2 | unit tests | Encoding detection; Word's encoding choice dialog and line-ending options missing |
+| `.txt` Plain text | 2% | R/W | ✅ | ✅ | ~95% | 1–2 | unit tests | Encoding detection. Files with other extensions (`.m3u`/`.m3u8` playlists, logs, config files, no extension) open as text when they are text, Word and RTF files by their signature; binary files are refused (#569). Word's encoding choice dialog and line-ending options missing; such files save only through Save As |
 | `.htm/.html` Web Page and Web Page, Filtered | 1% | R/W | 🟡 | 🟡 | ~60% | 6–10 | `crates/formats/src/tests.rs` | Tables (#102), relative pictures embedded (#113), missing `</head>` tolerated (#154). No Word "Web Page" (with `_files` folder) round-trip |
 | `.mht/.mhtml` Single File Web Page | <1% | R/W | ❌ | ❌ | 0% | 3–5 | — | |
-| `.xml` Word XML Document (Flat OPC) | <1% | R/W | ❌ | ❌ | 0% | 3–5 | — | The DOCX parts in one XML file; cheap once the DOCX code is reused |
-| `.xml` Word 2003 XML (WordprocessingML 2003) | <1% | R/W | ❌ | ❌ | 0% | 5–8 | — | Legacy |
+| `.xml` Word XML Document (Flat OPC) | <1% | R/W | ✅ | ✅ | ~65% | — | `crates/docx/tests/word_xml.rs`, `roundtrip.rs` (`flat_opc_round_trip_equals_docx`) | The DOCX package in one XML file, read and written by the DOCX code (#548); File › Export › Word XML Document. `.xml` files are told apart by their root element |
+| `.xml` Word 2003 XML (WordprocessingML 2003) | <1% | R/W | 🟡 | ❌ | ~55% | 2–3 | `crates/docx/tests/word_xml.rs` | Opened by rewriting it as a package for the DOCX reader (#548): styles, default fonts, lists, tables, sections, headers/footers, footnotes/endnotes, comments, bookmarks, tracked insertions/deletions, hyperlinks, `w:binData` pictures, document properties. Not read: formatting changes, `w:docPr` settings, smart tags. Saving as 2003 XML is not planned (legacy) |
 | `.wps` Works 6–9, WordPerfect `.wpd` (Windows) | <1% | R | ❌ | — | 0% | 10–20 | — | Windows-only converters; low value |
 | Encrypted/password-protected `.docx`/`.doc` | 1% | R/W | ❌ | ❌ | 0% | 6–10 | — | ECMA-376 Agile Encryption; `.doc` RC4/XOR detected and refused (`docbin` fib). Issue #55 |
 | `.xlsx`/`.xlsm`/`.ods` as a mail-merge recipient list | — | R (data source) | ✅ | — | ~90% | 1–3 | `crates/formats/src/sheet.rs`, `cmd/mailings.rs` | Read-only, one sheet's cell values (#334): shared/inline/rich strings, numbers, booleans, cached formula results, dates and times as ISO 8601 (`yyyy-mm-dd`) from the cell's number format, sparse cells; ODS value types, repeated rows/columns, covered cells. Select Table picks the sheet. Capped (64 MiB per part, 100,000 rows, 1,000 columns, 2 M cells, 32,767 characters a cell). Not shown: number formats other than dates (currency, percent, thousands separators) in `.xlsx`; no `.xls`, Access or Outlook sources |
@@ -46,56 +46,125 @@ Measured by grepping `crates/docx/src/read` and `src/write` for the OOXML elemen
 
 | Feature | Read | Write | Notes |
 |---|---|---|---|
-| Text, runs, paragraph and character properties, styles, numbering, sections | ✅ | ✅ | Including complex-script props (`w:rtl`, `w:cs`, `w:szCs`, `w:bCs`…), East Asian fonts kept apart from Latin (#111) |
+| Text, runs, paragraph and character properties, styles, numbering, sections | ✅ | ✅ | Including complex-script props (`w:rtl`, `w:cs`, `w:szCs`, `w:bCs`…), East Asian fonts kept apart from Latin (#111), indents in characters (`w:firstLineChars`, `w:hangingChars`, `w:leftChars`, `w:rightChars`, #534); every ST_NumberFormat value of `w:numFmt` is kept on save, Chinese/Japanese/Korean, enclosed and full-width formats are drawn, the rest (Hebrew, Arabic, Hindi, Thai…) show decimal (#534). `w:beforeLines`/`w:afterLines` not kept (the points are) |
 | Tables incl. floating (`w:tblpPr`), table styles and conditional formatting | ✅ | ✅ | Custom table styles round-trip (#256); right-to-left tables (`w:bidiVisual`) and sections (`w:bidi`) round-trip (#362) |
 | Headers/footers (first, even/odd), page borders, line numbers, gutter, mirror margins | ✅ | ✅ | |
+| Hyphenation settings (`w:autoHyphenation`, `w:hyphenationZone`, `w:doNotHyphenateCaps`, `w:consecutiveHyphenLimit`) | ✅ | ✅ | Zone, capitals and limit kept and honoured by layout (#407) |
 | Footnotes, endnotes, comments | ✅ | ✅ | The document's own note separators and continuation notice (`w:type` `separator`, `continuationSeparator`, `continuationNotice`) round-trip as ids -1, 0 and 1 (#352); note options (`w:pos`, `w:numFmt`, `w:numStart`, `w:numRestart`) round-trip in the settings and in each `w:sectPr` (#385); `commentsExtended` written; `commentsIds`, modern threaded comments (`w16cex`) partly |
 | Tracked insertions and deletions (`w:ins`/`w:del`), paragraph-mark revisions | ✅ | ✅ | #125, #244 |
 | Formatting revisions (`w:rPrChange`, `w:pPrChange`, `w:sectPrChange`, `w:tblPrChange`, `w:trPrChange`, `w:tcPrChange`, `w:numberingChange`) | ✅ | ✅ | #41: kept on open and save, schema order (change element last); changes inside `styles.xml` are dropped. RTF/ODT ignore them |
 | Move tracking (`w:moveFrom`/`w:moveTo`, `w:moveFromRangeStart/End`, `w:moveToRangeStart/End`), moved paragraph marks | ✅ | ✅ | #400: both ends linked by the range name; ranges rewritten around each moved stretch (ids renumbered); a move missing an end or a range end opens as a plain deletion/insertion. RTF/ODT/PDF export the result (moved-away text hidden like deletions) |
-| Fields (`w:fldChar`, `w:fldSimple`), TOC, cross-references, `ADDIN` citations | ✅ | ✅ | Field codes Word supports but we don't evaluate keep their cached result. `EQ \o` (overstrike, enclosed characters) is drawn; enclosed characters are written as Word stores them, their style in the code's run sizes (#297) |
-| Content controls (`w:sdt`) | 🟡 | ❌ | Content kept, the control (type, binding, placeholder, lock) dropped |
+| Fields (`w:fldChar`, `w:fldSimple`), TOC, cross-references, `ADDIN` citations | ✅ | ✅ | Field codes Word supports but we don't evaluate keep their cached result. `EQ \o` (overstrike, enclosed characters) is drawn; enclosed characters are written as Word stores them, their style in the code's run sizes (#297); a cached picture (`INCLUDEPICTURE`) stays as the content of a range field (#465) |
+| Content controls (`w:sdt`) | ✅ | ✅ | Block, inline, row and cell level, nested; title, tag, id, lock, placeholder, temporary, rich/plain text, `w14:checkbox`, combo box, drop-down list, date, picture, building block gallery, `w15` repeating sections; other `w:sdtPr` children (data binding, appearance) kept verbatim (#381). A TOC's control is rebuilt by the TOC |
+| Restrict Editing (`w:documentProtection` edit/formatting/enforcement and password hash, `w:locked` styles, `w:permStart`/`w:permEnd` exceptions) | ✅ | ✅ | #412: SHA-512 hash with salt and spin count written; Word's legacy `w:cryptAlgorithmSid`/`w:hash` form (SHA-1/-256/-384/-512, ECMA-376 Part 4 §14.8.1) is kept and verified; MD2/MD4/MD5, `w:algIdExt` and other unsupported forms are refused, never unlocked; `w:colFirst`/`w:colLast` table-column ranges read as plain ranges |
 | Legacy form fields (`w:ffData`), check boxes, drop-downs | ❌ | ❌ | |
 | DrawingML pictures inline and anchored (`wp:anchor`), wrap square/tight/through/top-bottom | ✅ | ✅ | Tight/through read and written with their `wp:wrapPolygon` (and `edited`); without one, a shape's outline is written (a picture's rectangle). `wrapText` (both sides, left, right, largest) read and written for square, tight and through |
-| DrawingML shapes and text boxes (`wps:`) | ✅ | ✅ | Preset geometries subset; rotation and flips (`a:xfrm` `rot`/`flipH`/`flipV`, pictures and groups too, #332), the effect extent covering the rotated bounds; `wps:bodyPr` `vert` and `anchor`, linked text boxes (`wps:txbx/@id`, `wps:linkedTxbx` `id`/`seq`, #369) |
+| WordArt text effects (`w14:textFill`, `w14:textOutline`, `w14:shadow`, `w14:glow`, `w14:reflection` in `w:rPr`) | ✅ | ✅ | Solid, gradient (linear) and no fill, outline colour/width, shadow, glow, reflection (#416); `w14:scene3d`/`w14:props3d` dropped |
+| DrawingML shapes and text boxes (`wps:`) | ✅ | ✅ | Preset geometries subset (callouts and flowchart boxes drawn as the nearest shape, #611); fill and outline from the shape or from the theme through its style references (`a:fillRef`/`a:lnRef`, #611), scheme, preset, system, scRGB and HSL colours; rotation and flips (`a:xfrm` `rot`/`flipH`/`flipV`, pictures and groups too, #332), the effect extent covering the rotated bounds; `wps:bodyPr` `vert` and `anchor`, linked text boxes (`wps:txbx/@id`, `wps:linkedTxbx` `id`/`seq`, #369); text warps (`a:prstTxWarp` with adjust values, all 41 presets kept; unknown ones dropped), connectors (`straightConnector1`, `bentConnector2`–`5`, `curvedConnector2`–`5` read; 3-segment forms written) with glued ends (`wps:cNvCnPr` `a:stCxn`/`a:endCxn`; the glued shapes keep their drawing ids) and arrowheads (`a:headEnd`/`a:tailEnd`, drawn as triangles) (#416) |
 | Freeform shapes (`a:custGeom`: `a:moveTo`, `a:lnTo`, Bézier curves flattened) and WordCraft ink | ✅ | ✅ | Ink is written as a freeform `wps:wsp` in a `wp:anchor` (round caps, alpha for highlighter) and recognised again by its drawing name (#307). It is saved as a custom-geometry shape, not as Word's own ink (InkML in `w14:contentPart`), so Word shows WordCraft ink as a freeform shape it can move and recolour but not erase with its ink eraser; arcs drawn straight |
 | Group shapes (`wpg:`), drawing canvas (`wpc:`) | ✅ | ✅ | Groups (#267) and canvases (#344) with pictures, shapes and text boxes; nested groups flattened. The canvas schema has no transform, so a turned or flipped canvas keeps its turn in our own `wpc:extLst` extension (`urn:wordcraft:canvas-xfrm`; Word shows it unturned). Legacy VML canvases (`v:group editas="canvas"`) aren't read as canvases |
-| VML (`w:pict`, `v:shape`, `v:textbox`) | 🟡 | ❌ | Pictures and text boxes, best effort (#242) |
-| Charts (`c:chart`), SmartArt (`dgm`) | ✅ | ✅ | Drawn from the chart's cached data and SmartArt's stored drawing (#292); not editable. Saved back as read, with every part they reach (chart, embedded workbook, colours and style; diagram data, layout, quick style, colours and drawing) and their content types; a moved or resized one keeps its new frame, and a pasted copy gets its own parts (#319) |
+| VML (`w:pict`, `v:shape`, `v:textbox`) | 🟡 | ❌ | Pictures, text boxes, lines (with arrowheads), rectangles and ovals, best effort (#242, #611) |
+| Alt text of drawings (`wp:docPr`/`cNvPr` `descr` and `title`, decorative mark `adec:decorative` from [MS-ODRAWXML]) and tables (`w:tblCaption`, `w:tblDescription`) | ✅ | ✅ | Pictures, shapes, text boxes, groups and their members, charts and SmartArt; OLE objects get theirs written into the kept XML (#386) |
+| Charts (`c:chart`), SmartArt (`dgm`) | ✅ | ✅ | Drawn from the chart's cached data and SmartArt's stored drawing (#292), with data labels (`c:showVal`). Charts made in WordCraft (Insert › Chart, #409) are written as a `c:chartSpace` part with their data as literals (`c:strLit`/`c:numLit`, no embedded workbook, so Word shows them and offers to create a workbook on Edit Data) and read back as editable; a chart part holding anything more (any chart from Word, or one re-saved by Word) stays read-only. Saved back as read, with every part they reach (chart, embedded workbook, colours and style; diagram data, layout, quick style, colours and drawing) and their content types; a moved or resized one keeps its new frame, and a pasted copy gets its own parts (#319). SmartArt made in WordCraft (#497) is written from its model: data (`dgm:dataModel` points and connections), our own layout, quick-style and colour definitions under the built-in layout identifiers, and a `dsp:drawing` with every shape placed; it reads back editable only when its data part is exactly what WordCraft writes |
 | OLE objects (`w:object`: embedded or linked files, ActiveX) | 🟡 | ✅ | Shown as their picture (VML or DrawingML); saved back whole with the embedding and picture parts, at the size, rotation and flips set in WordCraft (#319, #332). Can't be opened or edited |
 | Word ink (`w14:contentPart`, InkML), 3D models | ❌ | ❌ | Dropped on read, not preserved on save |
 | Equations (OMML `m:oMath`) | ✅ | ✅ | #191; manual breaks (`m:brk`) and the settings' `m:mathPr` wrapping options (#326) |
-| Themes, font table, settings, compatibility mode | ✅ | ✅ | Embedded fonts (`w:embedRegular`) not read |
-| Custom XML parts, document properties, bibliography sources | 🟡 | 🟡 | Custom properties round-trip; bibliography sources pending (#169) |
+| Themes, font table, settings, compatibility mode | ✅ | ✅ | Embedded fonts (`w:embedRegular`) not read; attached template (`w:attachedTemplate` and its external relationship) and `w:linkStyles` round-trip (#377). The template path comes from the file, so opening never reads it: styles update from it only on an explicit Update Styles |
+| Custom XML parts, document properties, bibliography sources | 🟡 | 🟡 | Custom XML stores reached from the package/main document preserve opaque data, properties and relationships; binding evaluation remains absent. Custom properties round-trip; bibliography model I/O remains separate (#532 open) |
+| Section text direction (`w:textDirection` in `w:sectPr`, §17.6.20) | ✅ | ✅ | `tbRl`, `btLr` (and `tbRlV`/`tbLrV`, read as `tbRl`); `lrTbV` and unknown values read as horizontal (#491) |
 | Ruby (`w:ruby`: `w:rubyPr`, `w:rt`, `w:rubyBase`) | ✅ | ✅ | #288; base and ruby text with their run formatting, alignment, sizes, raise, language |
 | Document grid (`w:docGrid`: type, line pitch, `w:charSpace`), paragraph `w:snapToGrid` | ✅ | ✅ | #391; run-level `w:snapToGrid` not read |
 | `w:eastAsianLayout`, `w:fitText` | ❌ | ❌ | East Asian layout |
 | Glossary document (building blocks), `w:altChunk`, sub-documents | ❌ | ❌ | |
 | Hostile input | ✅ | — | `malformed.rs`, capped allocations, never-crash standard |
+| Document paragraph defaults (`w:pPrDefault`) | ✅ | ✅ | Omission and explicit empty defaults remain distinct across repeated saves; nonempty defaults and later default-spacing edits are written |
 
+## Paragraph-default preservation
+
+The styles reader records whether `w:pPrDefault` exists. The writer keeps an omitted
+container omitted when its modeled properties are still empty. An explicitly empty
+container stays present, and editing document-default spacing writes the new values.
+New documents and older serialized style sheets keep their explicit defaults.
+`crates/docx/tests/fixtures.rs` covers omitted `docDefaults`, omitted paragraph defaults,
+empty containers and populated defaults across two save/reopen cycles. This preserves
+application-defined defaults without assigning inferred Word spacing values to the model.
+Observed in Word for Mac 16.113.3 (26092714): three synthetic paragraph-default
+controls (omitted, explicitly empty, populated) and two reduced invoice controls retain
+identical text, glyph/image geometry, page sizes and embedded font-program hashes through
+two WordCraft save/reopen cycles. All fifteen variants open without repair warnings.
+Word PDFs and measurements remain local under ignored `plan/word/`; they are not fixtures.
+These checks cover preservation on Word reopen, not WordCraft pagination parity.
+
+The [public OOXML reference](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.wordprocessing.paragraphpropertiesdefault?view=openxml-3.0.1)
+describes omission as leaving paragraph defaults application-defined. Real-world corpus
+coverage and WordCraft layout matching remain separate gaps.
+
+## Custom XML store preservation
+
+A reduced original bound-control DOCX loses its backing data, item properties and relationship
+on main, both without editing and after unrelated edits. Main's content-control support (#381)
+preserves control metadata, including binding attributes, while this custom XML path keeps the
+backing store through the bounded opaque part graph: payload bytes, content types and
+related-part IDs survive two edited save/reopen cycles.
+
+The public [dataBinding contract](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.wordprocessing.databinding?view=openxml-3.0.1)
+maps a control to a custom XML data part; its [item properties](https://learn.microsoft.com/en-us/dotnet/api/documentformat.openxml.customxmldataproperties.datastoreitem?view=openxml-3.0.1)
+identify the store. Keeping displayed text alone does not preserve that mapping. This change
+preserves stores without evaluating XPath or synchronizing control edits into XML.
+
+Focused original tests cover package/main roots, multiple/shared stores, cycles, external schema
+references, missing parts, UTF-16 payloads, strict relationship types and reserved filenames.
+The bibliography names used by #532 are reserved; bibliography already loaded into the source
+model belongs to its writer. Word-derived files are not fixtures. No readiness estimate rises
+from these synthetic package checks, and native Word rendering/binding behavior remains untested.
+
+## Native save-path guarantees
+Native `io::save_path_with` serializes (and, for password-protected DOCX, encrypts) before creating an exclusively owned sibling temporary file. It writes and synchronizes that file, closes it, then replaces the destination. Failed preparation or replacement keeps the original bytes; cleanup removes only the save's temporary file, on a best-effort basis. Existing `<name>.tmp` files, directories and links are untouched. A new document gets the default mode (`0666` less the umask). When replacing an existing regular file, the Unix temporary file starts with mode `0600` and then takes the existing file's basic permissions. Serialization and format support are unchanged.
+Synthetic CLI cases and `engine/tests/safe_save.rs` cover occupied names, links, blocked replacement, missing directories, Save As session state, password-protected saves and original-file protection on macOS. Unit tests inject preparation errors and interleave two prepared saves. Independent saves use separate files; the last successful replacement wins. This is not document locking or conflict detection.
+Windows/Linux runtime behavior, ACLs and extended metadata, real disk-full conditions, power loss and network filesystems are not verified by these tests. The containing directory is not explicitly synchronized. Cleanup can fail when storage or permissions change, and process termination can leave a temporary file. No Word observation was needed for this filesystem change; it makes no new format-fidelity claim.
 ## What decides beta for formats
 
 1. A **real-world DOCX corpus** opened, rendered and round-tripped, compared page by page with
    Word (local only: Word output can't be committed; keep a manifest and our own renders).
-2. **Preserve what we can't render**: ink, group shapes and content controls survive a round trip
+2. **Preserve what we can't render**: ink and drawing canvases survive a round trip
    (keep the parts and the run). Charts, SmartArt and OLE objects do (#292, #319).
-3. Formatting revisions and content controls read and written.
+3. Move tracking (`w:moveFrom`/`w:moveTo`) read and written (formatting revisions: #41; content controls: #381).
 4. Encrypted `.docx` opens with a password.
 
 ## Revision history
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | trivial | Word XML Document (Flat OPC) read and written, Word 2003 XML read (#548) |
+| 2026-10-11 | trivial | #534: DOCX indents in characters read and written; `.doc` first-line indents (`sprmPDxaLeft1`, its two-byte operand, and `sprmPDxaLeft1_80`), indents in characters (`sprmPDxc*`) and exact/at-least line spacing (LSPD) read correctly |
+| 2026-10-11 | trivial | List and page number formats: all ST_NumberFormat values round-trip; Chinese, Japanese and Korean counting, legal and digit formats, stems/branches, kana, hangul, enclosed and full-width numbers drawn; unknown values are decimal; .doc number format codes mapped (#534) |
+| 2026-10-11 | trivial | SmartArt made in WordCraft written as diagram parts (data, layout, quick style, colours, drawing) and read back editable (#497) |
+| 2026-10-11 | trivial | Attached template (`w:attachedTemplate`, external relationship of the settings part) and `w:linkStyles` read and written in schema order; opening never reads the template (#377) |
+| 2026-10-11 | trivial | A bookmark (or comment range) ending after the document's last table keeps its end, in the table's last cell (#464); a field whose cached result is a picture (`INCLUDEPICTURE`) is kept as a range field around the picture, so the picture survives save; the linked file is never read (#465) |
+| 2026-10-11 | trivial | Print Markup: comments exported in PDFs, prints, page images and HTML/Markdown/text copies (#589) |
+| 2026-10-11 | trivial | Files with an extension WordCraft doesn't know open by content: text (`.m3u`/`.m3u8` playlists, logs…) through the encoding-detecting text import, misnamed Word/RTF files by signature, binary files refused with an error (#569) |
+| 2026-10-11 | trivial | Restrict Editing: Word's legacy password hash (`w:cryptAlgorithmSid`, `w:hash`, `w:salt`, `w:cryptSpinCount`) verified per ECMA-376 Part 4 §14.8.1; unsupported hash forms refused (#412) |
+| 2026-10-11 | trivial | Restrict Editing: `w:documentProtection` (edit, formatting, password hash), `w:locked` styles and `w:permStart`/`w:permEnd` exceptions read and written (#412) |
+| 2026-10-11 | trivial | DOCX diagrams (#611): shapes and connectors styled by the theme (`wps:style`) show their outline and fill; preset/system colours; VML lines and rectangles; lines run top-left to bottom-right as in DrawingML |
+| 2026-10-11 | trivial | WordArt text effects (`w14:` run properties), text warps (`a:prstTxWarp`) and connectors with glued ends read and written (#416) |
+| 2026-10-11 | trivial | Content controls read and written with their properties and nesting (#381) |
+| 2026-10-11 | trivial | Charts made in WordCraft written as chart parts and read back as editable (#409) |
+| 2026-10-11 | trivial | Hyphenation zone, words in capitals and consecutive-hyphen limit read and written (#407) |
+| 2026-10-11 | trivial | Alt text, titles and the decorative mark for every drawing, table captions and descriptions round-trip (#386) |
 | 2026-10-11 | trivial | Document grid (`w:docGrid`) and paragraph `w:snapToGrid` read and written (#391) |
 | 2026-10-11 | trivial | Move tracking (`w:moveFrom`/`w:moveTo` and their ranges) read and written (#400) |
 | 2026-10-11 | trivial | DOCX text-box `bodyPr` `vert`/`anchor` and linked text boxes (`wps:linkedTxbx`) read and written (#369) |
 | 2026-10-10 | trivial | Right-to-left tables (`w:bidiVisual`) read and written (#362) |
 | 2026-10-10 | trivial | Drawing canvas (`wpc:wpc`) read and written (#344); group shapes row brought up to date (#267) |
 | 2026-10-11 | trivial | Spreadsheets (.xlsx/.xlsm/.ods) read as mail-merge recipient lists (#334) |
+| 2026-10-12 | minor | Preserve opaque custom XML stores and related properties; bindings and control support remain separate |
+| 2026-10-11 | trivial | Native saves protect existing temporary-name entries and originals on pre-replacement failure; synthetic macOS evidence, explicit durability/platform limits; readiness unchanged |
 | 2026-10-11 | trivial | Import/export fixes (#433–#440): TXT opens through the encoding-sniffing reader (Windows-1252, unmarked UTF-16) and saves list labels; RTF `\uN` in document info, bookmark names and field instructions; ODT common paragraph styles' text formatting and table-cell background colours; HTML borderless tables export without cell borders and `white-space:pre` keeps edge spaces; LaTeX brace groups scope `\centering`/`\raggedleft`/`\raggedright` |
 | 2026-10-11 | trivial | `.doc` import fixes per [MS-DOC]: piece Prm0/Prm1 decoding (#458), section-break kinds (#459), explicit orientation (#460), negative `sprmPIlfo` list references (#461), zero-based `istdBase` style inheritance (#462), font-table entries with alternate names (#463) |
 | 2026-10-11 | trivial | Formatting revisions (`w:rPrChange`, `w:pPrChange`, table, row, cell, section and numbering changes) read and written (#41) |
+| 2026-10-11 | trivial | Omitted `w:pPrDefault` stays omitted across saves; explicit empty/default properties and later spacing edits remain writable. Synthetic preservation checks only; readiness estimates unchanged |
 | 2026-10-10 | trivial | OLE objects turned or flipped in WordCraft keep the turn on save (VML `rotation`/`flip`, DrawingML `a:xfrm` with the rotated effect extent); test counts refreshed |
+| 2026-10-11 | trivial | Section text direction read and written (#491) |
 | 2026-10-10 | trivial | Charts, SmartArt and OLE objects written back on save with their parts (#319); chart/SmartArt reading (#292) recorded |
 | 2026-10-10 | trivial | Footnote and endnote separators and continuation notices read and written (#352) |
 | 2026-10-11 | trivial | Enclosed characters (`EQ \o\ac`) read, drawn and written (#297) |
diff --git a/docs/gaps.md b/docs/gaps.md
index 2eb51c88c0..30b97603b7 100644
--- a/docs/gaps.md
+++ b/docs/gaps.md
@@ -7,28 +7,30 @@ The work list. One entry per shortfall, ranked by how much it stops a Word user
 wall-clock estimate, and which parity document tracks it. Agents: pick from the top, check open PRs
 first (`gh pr list`), and update this file and the parity doc when a gap closes.
 
+Native save reliability: synthetic cases on macOS reproduced loss through the predictable temporary-file name. Saves now use owned, exclusively created siblings, synchronize before replacement and clean up on failure; originals survive pre-replacement errors. This narrows save-path reliability under gap #3; the listed field failures and broader stability work remain open. See [save-path guarantees](file-format-parity.md#native-save-path-guarantees).
+
 ## Ranked
 
 | # | Gap | B | Evidence | Impact | Hours | Doc |
 |---|---|---|---|---|---|---|
-| 1 | **DOCX never tested on real-world files.** No corpus of files from Word, Google Docs, LibreOffice and Pages has been opened, rendered and round-tripped and compared with Word page by page | B | No corpus in the repo; `crates/docx/tests` are synthetic fixtures; "DOCX fidelity corpus: not started" since 2026-10-06 | Everyone: the files people receive are the files that break | 30–50 | [file-format-parity.md](file-format-parity.md) |
+| 1 | **DOCX never tested on real-world files.** No corpus of files from Word, Google Docs, LibreOffice and Pages has been opened, rendered and round-tripped and compared with Word page by page | B | No corpus in the repo; `crates/docx/tests` are synthetic fixtures (including omitted/empty paragraph-default preservation); "DOCX fidelity corpus: not started" since 2026-10-06 | Everyone: the files people receive are the files that break | 30–50 | [file-format-parity.md](file-format-parity.md) |
 | 2 | **Ink and drawing canvases are dropped on open and lost on save, silently**; OLE objects show only their picture | B | No ink or drawing-canvas (`wpc`) handling in `crates/docx`; group shapes (`wpg`) read and written (#267). Charts and SmartArt are drawn (#292) and, with OLE objects, written back with all their parts on save (#319) | Documents with diagrams drawn in Word or pen notes lose content without warning | 4–8 to preserve ink and drawing canvases; 45–70 to render and edit charts and SmartArt (#13) | [file-format-parity.md](file-format-parity.md) |
 | 3 | **Crashes and freezes in the field**: startup crash on Intel UHD Graphics (#170) (lag on GPUs without a DirectX 12 driver fixed, #316), freezes (#77, #59 Thai fonts, #31 font selector), no writes without admin on Windows 11 (#218), broken shape tool (#142), images can't be moved (#82) | B | 62 open issues, ~15 of them crashes, hangs or data-path failures | Anyone hit loses work or trust; the never-crash standard covers panics, not hangs or GPU driver faults | 20–30 | [target-app-parity.md](target-app-parity.md) (Stability) |
 | 4 | **Pagination differs from Word**: Aptos has no metric-matched substitute; legacy compatibility options ignored; no page-by-page comparison harness | B | [layout-parity.md](layout-parity.md); [typing-parity.md](typing-parity.md) Known gaps | Page counts and line breaks differ, which matters for forms, legal and academic work | 30–50 + owner (font) | [layout-parity.md](layout-parity.md) |
-| 5 | **Content controls** are lost (`w:sdt` unwrapped). Move tracking landed (#400): `w:moveFrom`/`w:moveTo` with their named ranges round-trip, a tracked cut and paste of a paragraph or sentence records a move, either end accepts/rejects both, green double strike/underline markup and "Moved from/to" balloons; still missing: drag-and-drop moves (no text drag yet) and move options in Track Changes Options. Formatting revisions landed (#41): `w:rPrChange`/`w:pPrChange`/`w:tblPrChange`/`w:trPrChange`/`w:tcPrChange`/`w:sectPrChange`/`w:numberingChange` round-trip, are recorded while tracking, accepted/rejected and shown in balloons; still missing: tracked style-definition changes and table/section changes made in WordCraft | B | Issues #41, #400; source grep | Legal and editorial review workflows; templates with form controls | 5–8 | [file-format-parity.md](file-format-parity.md) |
-| 6 | **No native printing** on desktop: File › Print opens the PDF in the system viewer, which prints (#286); no print dialog of our own (printer, copies, ranges); web prints through the browser (#209) | B | `ui.print` → `apps/wordcraft/src/print.rs`; issue #15 | Everyone who prints | 5–8 | [hardware-parity.md](hardware-parity.md) |
-| 7 | **Dialog depth**: 35 modal dialogs vs Word's ~100 (Caption, Index, TOC options, Citation, Compare, Protect, Language, Hyphenation, Line Numbers, Envelopes, Labels, AutoCorrect, Options panes…) | B | `Dialog` enum in `crates/ui-egui/src/dialogs.rs` | Power users reach for dialogs the ribbon alone doesn't cover | 20–30 | [ui-parity.md](ui-parity.md) |
+| 5 | **Content controls** landed (#381): `w:sdt` kept, shown and edited (Developer tab, Design Mode, Properties). Move tracking landed (#400): `w:moveFrom`/`w:moveTo` with their named ranges round-trip, a tracked cut and paste of a paragraph or sentence records a move, either end accepts/rejects both, green double strike/underline markup and "Moved from/to" balloons; still missing: drag-and-drop moves (no text drag yet) and move options in Track Changes Options. Formatting revisions landed (#41): `w:rPrChange`/`w:pPrChange`/`w:tblPrChange`/`w:trPrChange`/`w:tcPrChange`/`w:sectPrChange`/`w:numberingChange` round-trip, are recorded while tracking, accepted/rejected and shown in balloons; still missing: tracked style-definition changes and table/section changes made in WordCraft. Opaque custom XML backing stores now survive saves; binding evaluation remains absent. | B | Issues #41, #400; source grep | Legal and editorial review workflows; templates with form controls | 5–8 | [file-format-parity.md](file-format-parity.md) |
+| 6 | **No native printing** on desktop: File › Print opens the PDF in the system viewer, which prints (#286); File › Print has a preview, page range, odd/even, copies and collate (#641); printer choice, duplex and pages per sheet are still the system's; web prints through the browser (#209) | B | `ui.print` → `apps/wordcraft/src/print.rs`; issue #15 | Everyone who prints | 5–8 | [hardware-parity.md](hardware-parity.md) |
+| 7 | **Dialog depth**: 54 modal dialogs vs Word's ~100 | B | `Dialog` enum in `crates/ui-egui/src/dialogs.rs` | Power users reach for dialogs the ribbon alone doesn't cover | 11–19 | [ui-parity.md](ui-parity.md) |
 | 8 | **Proofing covers English and Polish only**; no dictionaries, grammar or hyphenation for the other ~48 languages Word proofs (text in them is left unmarked) | | `crates/proof`: English and Polish, a language per run (2026-10-10); Word ships 120 proofing tools; issues #25, #40, #100 | Every writer outside English and Polish | 20–40 | [localization-parity.md](localization-parity.md) |
 | 9 | **Password-protected files** can't be opened or saved | | #55; `docbin` detects and refuses RC4/XOR | Corporate and legal users | 6–10 | [file-format-parity.md](file-format-parity.md) |
-| 10 | **Objects**: no group (#267 open), text in a freely rotated text box (free rotation and flips landed, #332; text direction, alignment and linked text boxes landed, #369; contour wrap and wrap side landed, #354), shape effects, WordArt, connectors, dragging members inside a Drawing Canvas (the canvas landed, #344) | | [parity-checklist.md](parity-checklist.md) (Shape Format 6/6, Layout › Group) | Newsletters, flyers, reports with diagrams | 20–30 | [target-app-parity.md](target-app-parity.md) |
+| 10 | **Objects**: no group (#267 open), text in a freely rotated text box (free rotation and flips landed, #332; text direction, alignment and linked text boxes landed, #369; contour wrap and wrap side landed, #354), shape effects, WordArt 3-D effects and connector routing around shapes (WordArt effects and warps and glued connectors landed, #416), dragging members inside a Drawing Canvas (the canvas landed, #344) | | [parity-checklist.md](parity-checklist.md) (Shape Format 6/6, Layout › Group) | Newsletters, flyers, reports with diagrams | 20–30 | [target-app-parity.md](target-app-parity.md) |
 | 11 | **Interface languages**: 8 of the 12 key languages missing (hi, ar, fr, id, de, ko, vi, pt-PT); no mirrored RTL interface; ~5% of strings still English in the six translated catalogs | | [localization-parity.md](localization-parity.md) | Most of the world's writers | 50–80 | [localization-parity.md](localization-parity.md) |
-| 12 | **Draw tab / ink**: pens, pencil, highlighter, eraser, Select and Hide Ink landed (#307); missing: Lasso Select, Add Pen, Ink to Shape, Ink to Math, Ink Replay, pressure, Word's own ink (`w14:contentPart`/InkML) | | [parity-checklist.md](parity-checklist.md) (Draw 5/11) | Pen and tablet users | 8–14 | [hardware-parity.md](hardware-parity.md) |
-| 13 | **Charts and SmartArt editing** (own renderer, chart data editing, SmartArt layouts) | | `insert.chart`, `insert.smartArt` missing | Reports and business documents | 45–70 | [target-app-parity.md](target-app-parity.md) |
+| 12 | **Draw tab / ink**: pens, pencil, highlighter, eraser, Select and Hide Ink landed (#307); Lasso Select, Add Pen, Ink to Shape and Ink Replay landed (#395); missing: Ink to Math, arrows in Ink to Shape, pressure, Word's own ink (`w14:contentPart`/InkML) | | [parity-checklist.md](parity-checklist.md) (Draw 9/11) | Pen and tablet users | 4–8 | [hardware-parity.md](hardware-parity.md) |
+| 13 | **Charts and SmartArt editing** (editing charts and SmartArt from Word, more chart types and formatting) | | `insert.chart` and Chart Design basics landed (#409): WordCraft's own charts are editable; charts from Word stay read-only (no embedded-workbook editing), no combo/3D/radar/stock charts, axis or series formatting; Insert › SmartArt landed (#497) for graphics WordCraft makes | Reports and business documents | 35–55 | [target-app-parity.md](target-app-parity.md) |
 | 14 | **`.doc` can't be written; metafile pictures and Word 6/95 files refused** | | `crates/docbin` is read-only | Users exchanging files with old Word or legacy systems | 25–40 | [file-format-parity.md](file-format-parity.md) |
 | 15 | **References depth**: sources not saved in DOCX (#169 open); no EndNote/Mendeley desktop integration | | Sources live only in the session (#169 open) | Students and researchers | 6–10 | [target-app-parity.md](target-app-parity.md) |
 | 16 | **Right-to-left completeness**: kashida, RTL in HTML/ODT/RTF; eight older RTL bug reports to re-verify after #207 (#215, #211, #199, #66, #63, #48, #19). RTL tables and sections landed (#362) | | [layout-parity.md](layout-parity.md) | Arabic, Persian, Hebrew writers | 7–11 | [layout-parity.md](layout-parity.md) |
-| 17 | **East Asian typography**: vertical text, Asian Typography options (Phonetic Guide landed, #288; Enclose Characters landed, #297; document grid landed, #391) | | Catalog misses `para.asianTypography` | Chinese, Japanese and Korean documents | 11–19 | [layout-parity.md](layout-parity.md) |
-| 18 | **Screen-reader access** to the document canvas untested | | AccessKit enabled; no tests | Blind and low-vision users; public-sector procurement | 10–15 | [ui-parity.md](ui-parity.md) |
+| 17 | **East Asian typography**: Asian Typography options (Phonetic Guide landed, #288; Enclose Characters landed, #297; document grid landed, #391; vertical text landed, #491) | | Catalog misses `para.asianTypography` | Chinese, Japanese and Korean documents | 11–19 | [layout-parity.md](layout-parity.md) |
+| 18 | **Screen-reader access** to the document canvas: exposed, not yet tried with real screen readers | | The canvas describes paragraphs, headings, lists, tables, links, pictures and the caret to AccessKit (#488), tested headlessly; no NVDA, VoiceOver or Orca run yet | Blind and low-vision users; public-sector procurement | 3–6 | [ui-parity.md](ui-parity.md) |
 | 19 | **RTF and ODT depth**: notes, comments, revisions, sections, RTL | | ~1,500 lines each in `crates/formats` | Users exchanging with LibreOffice or older tools | 18–27 | [file-format-parity.md](file-format-parity.md) |
 | 20 | **Performance on large real-world documents** unmeasured (500+ pages, many pictures) | | Only the 188-page sample benchmark | Thesis and book authors | 10–20 | [layout-parity.md](layout-parity.md) |
 | 21 | **Mail merge data sources**: no Outlook/Contacts, Access or database sources, no email merge; CSV, typed lists (#247) and Excel/OpenDocument spreadsheets (#334) only | | Select Recipients reads .csv/.tsv, .xlsx/.xlsm and .ods | Office administrators | 4–8 | [target-app-parity.md](target-app-parity.md) |
@@ -36,7 +38,7 @@ first (`gh pr list`), and update this file and the parity doc when a gap closes.
 | 23 | **PDF Reflow** (open a PDF as an editable document, Word for Windows) | | | Users who edit PDFs they receive | 30–50 | [file-format-parity.md](file-format-parity.md) |
 | 24 | **Default shortcuts**: ~135 of Word's ~250 (#330, #339, #343; Customize Keyboard #368, Customize Ribbon and the Quick Access Toolbar #379 landed) | | [ui-parity.md](ui-parity.md) | Power users | 4–7 | [ui-parity.md](ui-parity.md) |
 | 25 | **In-app AI assistant** (Copilot-style draft, rewrite, summarize) | | Chat PR #178 open | Users expecting Copilot | 15–30 + owner (provider) | [target-app-parity.md](target-app-parity.md) |
-| 26 | **Minor formats**: Flat OPC XML, Word 2003 XML, MHT, Works/WordPerfect | | | Rare | 20–35 | [file-format-parity.md](file-format-parity.md) |
+| 26 | **Minor formats**: MHT, Works/WordPerfect, saving Word 2003 XML | | Word XML Document (Flat OPC) opens and saves, Word 2003 XML opens (#548) | Rare | 15–28 | [file-format-parity.md](file-format-parity.md) |
 | 27 | **View windows**: Side by Side, Synchronous Scrolling, Arrange All, Switch Windows | | [parity-checklist.md](parity-checklist.md) (View 25/29) | Comparing documents | 3–5 | [ui-parity.md](ui-parity.md) |
 | 28 | **Dictate** | | `tools.dictate` missing | Dictation users | 8–15 + owner (speech model) | [hardware-parity.md](hardware-parity.md) |
 | 29 | **Equations**: ink equations | | #191 notes; long display equations wrap at operators (#326) | Maths-heavy documents | 2–3 | [layout-parity.md](layout-parity.md) |
@@ -53,8 +55,11 @@ The same gaps grouped the way the parity documents are, for agents working in on
   pane, Manage Styles, Group (open PRs exist for the first three — review and merge before
   re-implementing). Paste Special, Advanced Find, Column Selection, Style Inspector, custom table
   styles, and Draw Table and Eraser (#303) landed on 2026-10-10.
-- **UI/UX gaps:** #7, #18, #24; crop handles on the canvas (rotation handle landed, #332); table column drag on the
-  ruler (#49, #217); context menus for objects and tables; Linux title bar theming (#78).
+- **UI/UX gaps:** #7, #18, #24; crop handles on the canvas (rotation handle landed, #332); table column markers on the
+  ruler (#49; dragging borders and the resize handle on the page landed, #217); context menus for objects and tables; Linux title bar theming (#78); File ›
+  Options › Animation effects › Use system setting reads macOS (Reduce motion) and the Linux/BSD
+  desktops (`apps/wordcraft/src/animations.rs`) but hasn't been tried on a Mac or in a real
+  GNOME or KDE session yet.
 - **File-format gaps:** #1, #2, #5, #9, #14, #19, #23, #26; embedded fonts; glossary/building blocks.
 - **Hardware gaps:** #6, #12, #28; scanner/Continuity Camera insert; KDE soft text (#140).
 - **Localization gaps:** #8, #11, #16, #17; native-speaker review of every catalog (human).
@@ -64,6 +69,19 @@ The same gaps grouped the way the parity documents are, for agents working in on
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | trivial | Table column and row borders and the resize handle drag on the page (#217); UI/UX gap narrowed to the ruler's column markers |
+| 2026-10-11 | trivial | UI/UX gaps list: the system's animation setting is now read on macOS and the Linux/BSD desktops; trying it on real machines remains |
+| 2026-10-11 | trivial | Animation effects setting landed (File › Options › Accessibility); UI/UX gaps list: the system's animation setting isn't read on macOS or Linux/BSD yet |
+| 2026-10-11 | trivial | Word XML Document (Flat OPC) and Word 2003 XML opening landed (#548); gap #26 narrowed to 15–28 h |
+| 2026-10-11 | trivial | #13 narrowed: Insert › SmartArt with eight layouts, Text Pane and SmartArt Design landed (#497); 25–40 h left for charts |
+| 2026-10-11 | trivial | File › Options panes landed (#485); removed from the dialog-depth list |
+| 2026-10-11 | trivial | #18: the document canvas describes its text, structure and caret to screen readers through AccessKit (#488); real screen-reader testing remains |
+| 2026-10-11 | trivial | Compare / Combine Documents and AutoCorrect Options dialogs and the Restrict Editing pane landed (#412); removed from the dialog-depth list; duplicate #7 rows merged |
+| 2026-10-11 | trivial | #10: WordArt text effects and Transform warps, connectors glued to shapes (#416) |
+| 2026-10-11 | trivial | #5 narrowed: content controls kept, shown and edited (#381); move tracking remains |
+| 2026-10-11 | trivial | Insert › Chart landed (#409); gap #13 narrowed to editing Word's charts, more types and SmartArt, 35–55 h |
+| 2026-10-11 | trivial | Line Numbers, Hyphenation, Language, Envelopes and Labels dialogs landed (#407); gap #7 at 30 dialogs, 16–24 h; duplicated #7 rows merged |
+| 2026-10-11 | trivial | Caption, Index, Mark Index Entry, Custom Table of Contents, Source Manager and Create/Edit Source dialogs landed (#402); removed from the dialog-depth list |
 | 2026-10-11 | trivial | Document grid landed (#391); removed from the East Asian gap |
 | 2026-10-11 | trivial | Move tracking landed (#400); gap #5 narrowed to content controls, 5–8 h |
 | 2026-10-11 | trivial | #4: note options per section (below text, end of section, restart each section/page) and the Footnote and Endnote dialog (#385) |
@@ -72,13 +90,17 @@ The same gaps grouped the way the parity documents are, for agents working in on
 | 2026-10-11 | trivial | #4: columns balance before a continuous section break (#350) |
 | 2026-10-11 | trivial | #21: Excel (.xlsx/.xlsm) and OpenDocument (.ods) spreadsheets as recipient lists (#334); hours 6–10 → 4–8 |
 | 2026-10-11 | trivial | Insert › Icons landed (#309); removed from the objects gap |
+| 2026-10-12 | minor | Preserve opaque custom XML data/properties through saves; gap #5 and readiness remain unchanged |
 | 2026-10-11 | trivial | #24 narrowed: Customize Ribbon and Quick Access Toolbar customization landed (#379); the default shortcuts remain |
 | 2026-10-11 | trivial | #24 narrowed: Customize Keyboard landed (#368); Customize Ribbon and the Quick Access Toolbar remain |
+| 2026-10-11 | trivial | Native saves protect existing temporary-name entries and originals on pre-replacement failure; synthetic macOS evidence, explicit durability/platform limits; readiness unchanged |
 | 2026-10-11 | trivial | #24: Word's field keys (Alt+F9, Shift+F9, Ctrl+Shift+F9, Ctrl+F11, Ctrl+Shift+F11, F11, Shift+F11) (#339) |
 | 2026-10-10 | trivial | #24: 125 of ~250 keyboard shortcuts after #330 |
 | 2026-10-11 | trivial | Collapsed duplicate rows left by parallel merges |
 | 2026-10-11 | trivial | All 12 bibliography styles landed (#383); removed from References depth |
 | 2026-10-11 | trivial | Formatting revisions landed (#41); gap #5 narrowed to move tracking and content controls, 8–12 h |
+| 2026-10-11 | trivial | Omitted `w:pPrDefault` stays omitted across saves; explicit empty/default properties and later spacing edits remain writable. Synthetic preservation checks only; readiness estimates unchanged |
+| 2026-10-11 | trivial | #12 narrowed: Lasso Select, Add Pen, Ink to Shape and Ink Replay landed (#395) |
 | 2026-10-10 | trivial | Draw Table and Eraser landed (#303); removed from the feature-gap list |
 | 2026-10-10 | trivial | Tabs and Borders and Shading dialogs landed (#320); removed from the dialog-depth list |
 | 2026-10-10 | trivial | Columns, Symbol and Field dialogs landed (#321); removed from the dialog-depth list |
@@ -99,5 +121,6 @@ The same gaps grouped the way the parity documents are, for agents working in on
 | 2026-10-10 | trivial | Table Properties dialog landed (#44); removed from the dialog-depth list |
 | 2026-10-10 | trivial | Merged main: landed features removed from the feature-gap list |
 | 2026-10-10 | minor | Beta note restated: full number back to the additive ~60% (method aligned with the standard, no new evidence) |
+| 2026-10-11 | trivial | #491: vertical sections landed; vertical text removed from the East Asian gap |
 | 2026-10-10 | major | First version, from the full re-measure: 29 ranked gaps with evidence, impact and hours |
 | 2026-10-10 | trivial | #307: Draw tab pens, eraser and Hide Ink landed; ink gap narrowed |
diff --git a/docs/layout-parity.md b/docs/layout-parity.md
index 62b51b20db..42401d45bd 100644
--- a/docs/layout-parity.md
+++ b/docs/layout-parity.md
@@ -1,6 +1,6 @@
 # Layout and pagination parity with Microsoft Word
 
-> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** major (first version; line breaking, pagination and object placement checked against Word's behaviour from the layout source on origin/main) · **Target:** Microsoft Word (Microsoft 365) for Mac 16.113.4
+> **Last reviewed:** 2026-10-10 · **Last updated:** 2026-10-11 · **Change:** trivial (complex-script shaping and Myanmar line breaking, #604; previously trivial: body page totals, table-cell footnotes and bookmark link pages fixed, #450 #451 #455; previously major: first version; line breaking, pagination and object placement checked against Word's behaviour from the layout source on origin/main) · **Target:** Microsoft Word (Microsoft 365) for Mac 16.113.4
 
 A document only "opens correctly" if its pages break where Word breaks them: the same lines, the
 same page count, footnotes and pictures on the same pages. This checklist covers line breaking,
@@ -20,21 +20,26 @@ font can't match Word's metrics.
 |---|---|---|---|
 | Line breaking (UAX #14 with Word's exceptions: no break after `/`) | ✅ | `layout::tests::no_line_break_right_after_a_slash` | — |
 | Justification, Word 2013+ space shrinking (compat mode 15) | ✅ | #109 | — |
+| Complex scripts (Myanmar, Khmer, Indic): shaped per script run with OpenType fallback fonts, one cluster per syllable, Myanmar wraps between syllables | 🟡 | `layout::tests_complex` (#604). Khmer, Thai and Lao still wrap only at spaces (need a dictionary) | 4–8 |
 | Kashida justification (Arabic) | ❌ | no kashida in `crates/layout` | 3–5 |
 | Distributed / Thai distributed alignment | 🟡 | read; layout untested | 1–2 |
 | Default font metrics (Aptos, Calibri, Cambria…) | 🟡 | Carlito/Caladea/Liberation are metric-compatible for Calibri/Cambria/Arial/Times/Courier; **Aptos (Word's default since 2024) has no metric-compatible open substitute**, so new Word documents wrap differently ([typing-parity.md](typing-parity.md) Known gaps). Needs an owner decision (commission or license a metric-matched font) | 6–10 + owner |
+| Indents in characters (`w:firstLineChars`, `w:leftChars`…), measured in the paragraph mark's font size | ✅ | #534, `layout::tests::character_indents_use_the_paragraph_mark_size`; spacing in lines (`w:beforeLines`/`w:afterLines`) uses the stored points (needs the document grid) | — |
 | Line spacing (single, 1.5, double, at least, exactly, multiple), spacing before/after, contextual spacing | 🟡 | Word puts multiple-spacing extra below the text and collapses spacing differently (#135, #108 open) | 3–5 |
-| Widow/orphan control, keep with next, keep lines together, page break before | ✅ | `lib.rs` keep_next/keep_lines | — |
+| Widow/orphan control, keep with next, keep lines together, page break before | ✅ | `lib.rs` keep_next/keep_lines; a line holding only a page break stays at the bottom of a full page instead of leaving a blank page (#534) | — |
 | Tabs (left, center, right, decimal, bar), leaders | 🟡 | Bar tabs untested | 1–2 |
-| Hyphenation (automatic, 0.25" zone, soft hyphens, consecutive limit) | 🟡 | English patterns only; other languages hyphenate wrongly or not at all | in localization |
+| Hyphenation (automatic, zone from the document, words in capitals, soft hyphens, consecutive limit, Manual Hyphenation, #407) | 🟡 | English patterns only; other languages hyphenate wrongly or not at all | in localization |
 | Drop caps | ✅ | 2026-10-06 | — |
 | Columns, column breaks, separators, balancing | ✅ | Columns balance on a section's last page when the next section starts continuous (also at the document end, which Word only balances when the document ends with a continuous break); not after next-page/even/odd breaks or on a page with a column break; keep-together, keep-with-next, widow/orphan control and unsplittable rows can leave them slightly uneven (#350) | — |
 | Section breaks (next page, continuous, even, odd), different first page, odd/even headers | ✅ | Section breaks don't show in Draft view (#42) | 1–2 |
+| List labels: number formats (decimal, letters, roman, ordinal text, Chinese/Japanese/Korean counting and legal, 一〇一 digits, 甲乙丙, ①…⑳, full-width), `%n` text such as `第%1章` / `（%1）`, legal numbering | ✅ | `doc::cjk_numbers` tests, `layout::tests::chinese_counting_list_labels_and_their_font_runs`; a label mixing faces (digit + CJK comma) is drawn run by run (#534). Hebrew, Arabic, Hindi, Thai, Vietnamese and Russian formats show decimal | — |
+| Body top below a tall header, footer pushes body up | ✅ | #138; a footer taller than the bottom margin moves the body bottom up (#453), and a header or footer linked to the previous section takes its room too (#454) | — |
+| Footnotes at the page bottom, endnotes at the end, note numbering | 🟡 | A long note continues onto the next page at a line boundary (its first line stays with the reference), first in that page's note area under a full-width continuation separator (#352); the document's own separator, continuation separator and continuation notice are drawn (the notice under a note that continues); a long endnote continues on the next column or page at a line boundary (#456), and the caret finds note text on its continuation page (#457); per-section restart partial | 1–3 |
 | Body top below a tall header, footer pushes body up | ✅ | #138 | — |
 | Footnotes at the page bottom, endnotes at the end, note numbering | 🟡 | A long note continues onto the next page at a line boundary (its first line stays with the reference), first in that page's note area under a full-width continuation separator (#352); the document's own separator, continuation separator and continuation notice are drawn (the notice under a note that continues; endnotes use the document's separator but don't continue onto a page of their own); each section's note options: footnotes below the text, endnotes at the end of each section, start at, numbering restarted each section or each page (counted from where the notes land, at most three passes) (#385) | 1–2 |
 | Tables: row heights (at least/exact), rows split across pages, header rows repeat, Can't Split | ✅ | 2026-10-06, #138 | — |
 | Tables: autofit to contents/window, fixed widths, Word 2013 edge | 🟡 | #137; #44: AutoFit Contents measures each column's narrowest and widest text and shares the width like Word, once (not live as you type); cell preferred widths and spans still differ | 3–5 |
-| Floating tables (`w:tblpPr`) | 🟡 | #137; overlap rules untested | 2–3 |
+| Floating tables (`w:tblpPr`) | 🟡 | #137; one placed on the page or margin that would cover the text before it and doesn't fit below it moves to the next page (#534); overlap rules untested | 2–3 |
 | Nested tables | 🟡 | render; polish missing | 2–4 |
 | Floating pictures/shapes placement (relative to page/margin/column/paragraph/line/character) | ✅ | #136 | — |
 | Text wrap: square, top-and-bottom, behind, in front | ✅ | 2026-10-06 | — |
@@ -44,14 +49,16 @@ font can't match Word's metrics.
 | Page borders (from page edge or text), page colour, watermark | ✅ | | — |
 | Line numbers (restart per page/section, count by) | ✅ | | — |
 | Vertical page alignment | ✅ | | — |
+| Gutter, mirror margins, book fold, 2 pages per sheet | 🟡 | gutter and mirror margins (even pages put the inside margin and gutter on the right, #452; page-relative floats move with the text); book fold missing | 2–3 |
+| Document grid (`w:docGrid`, lines per page, characters per line) | ❌ | East Asian documents paginate differently without it | 4–6 |
+| Vertical text (`tbRl`) in sections and text boxes; cell text direction | ✅ | cell text direction (#245); text-box text direction (#369); vertical sections (`tbRl`/`btLr`, #491): the page's text area turned, lines top to bottom stacking right to left, ideographs, kana and Hangul upright, Latin on its side, caret and clicks through the turn. Missing: OpenType `vert` alternates (punctuation is moved, not substituted), arrow keys along vertical lines, upright pictures take turned room | 2–4 |
 | Gutter, mirror margins, book fold, 2 pages per sheet | 🟡 | gutter and mirror margins; book fold missing | 2–3 |
 | Document grid (`w:docGrid`, lines per page, characters per line) | 🟡 | #391: line grid snaps line heights to whole pitches (text centred in them; `w:snapToGrid` off opts a paragraph out); character grid puts East Asian characters on the character pitch (`linesAndChars`) or all text (`snapToChars`), Latin text proportional; View › Gridlines draws it. Not yet: run-level `w:snapToGrid`, grid in headers/footers, paragraph spacing in grid lines, Word's exact glyph placement in a cell | 1–2 |
-| Vertical text (`tbRl`) in sections and text boxes; cell text direction | 🟡 | cell text direction landed (#245); text-box text direction (rotate 90°, 270°, stacked) landed (#369); page-level vertical text and East Asian upright vertical glyphs missing | 8–12 |
 | Ruby / phonetic guide, enclose characters, combined characters | 🟡 | ruby (Phonetic Guide) landed (#288): ruby text over its base by alignment, line grows to fit, in PDF; enclose and combined characters missing; ruby not yet compared with Word page by page | 2–4 |
 | Bidirectional paragraphs, mixed-direction lines; RTL tables and sections | 🟡 | #207; RTL tables (#362): grid columns from the right edge, start alignment and indent from the right margin, cell margins and left/right borders mirrored, merged and turned cells and nested tables included; RTL sections (#362): newspaper columns right to left with the line between mirrored. Right-hand page gutter (`w:rtlGutter`) missing | 1 |
 | Equations: display layout, numbering, wrapping long display equations | ✅ | #191; long display equations break at top-level operators (`m:brkBin`, `m:brkBinSub`), manual breaks and `m:alnAt`, continuation lines indented by `m:wrapIndent` or set right (`m:wrapRight`) (#326) | — |
 | Hidden text excluded from breaking and hyphenation | ✅ | #173 | — |
-| Fields: PAGE, NUMPAGES, SECTIONPAGES, TOC page numbers | ✅ | #52 | — |
+| Fields: PAGE, NUMPAGES, SECTIONPAGES, TOC page numbers | ✅ | #52; totals in the body need a second pass once the page count is known (#451) | — |
 | Compatibility modes (Word 2003/2007/2010 layout for old files: `w:compat` options) | 🟡 | mode 15 behaviour; the ~60 legacy compat options are mostly ignored | 10–20 |
 | Page-by-page comparison harness against Word | ❌ | Run Word locally on our own synthetic documents, export PDF, compare line breaks; Word output stays under `plan/` (never committed) | 8–12 |
 
@@ -68,6 +75,14 @@ font can't match Word's metrics.
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | trivial | Chinese documents (#534): indents in characters, a page-anchored floating table after a full page moves to the next page, no blank page from a page break at the bottom of a full page |
+| 2026-10-11 | trivial | East Asian list number formats (一、二、三, 第一章, ①); list labels whose characters come from two fonts draw each part with its own font (the digits of "1、" no longer show as other letters); a list level without indents leaves the label at the paragraph edge (#534) |
+| 2026-10-11 | trivial | Vertical sections: `w:textDirection` in `w:sectPr`, upright East Asian glyphs (#491) |
+| 2026-10-11 | trivial | Mirror indents (`w:mirrorIndents`): left/right indents swap on even pages; suppress line numbers inherited from styles (#512) |
+| 2026-10-11 | trivial | NUMPAGES/SECTIONPAGES in the body show the real totals (the body is laid out again once the page count is known, at most three extra passes, #451); footnotes referenced in table cells go to the page bottom (#450); PDF links to a bookmark go to the page its start is on, not its paragraph's first page (#455) |
+| 2026-10-11 | minor | Complex scripts: script itemisation, OpenType fallback fonts, syllable clusters, Myanmar syllable breaks (#604) |
+| 2026-10-11 | trivial | Mirrored margins on even pages, tall and linked footers/headers push the body, long endnotes continue, caret in continued notes (#452, #453, #454, #456, #457) |
+| 2026-10-11 | trivial | Hyphenation zone, words in capitals and consecutive-hyphen limit follow the document settings; Manual Hyphenation (#407) |
 | 2026-10-11 | trivial | Document grid: line and character pitch (#391) |
 | 2026-10-11 | trivial | Linked text boxes, Align Text and text-box text direction (#369) |
 | 2026-10-11 | trivial | Right-to-left tables and sections laid out mirrored (#362) |
diff --git a/docs/localization-parity.md b/docs/localization-parity.md
index 1e9680a286..d82faa11df 100644
--- a/docs/localization-parity.md
+++ b/docs/localization-parity.md
@@ -46,7 +46,7 @@ shared items below.
 | Language | Code | UI strings translated | Dialogs / tooltips / help | Script support | Native review | Status | Hours to full |
 |---|---|---|---|---|---|---|---|
 | English | en | source (100%) | ✅ | Latin ✅ | yes | **full** | 0 |
-| Simplified Chinese (Mandarin) | zh-hans | 929 entries; 98% of extracted, ~95% of visible | most; newer panes English | CJK ✅, IME ✅; Windows UI font fixed (#248); no vertical text | no | partial | 3–5 |
+| Simplified Chinese (Mandarin) | zh-hans | 929 entries; 98% of extracted, ~95% of visible | most; newer panes English | CJK ✅, IME ✅; Windows UI font fixed (#248); interface font chain covers every catalog character, installed CJK font after the embedded ones when it doesn't, PingFang found on macOS 12 (#486); font list by Chinese names (宋体, 微软雅黑, #505); no vertical text | no | partial | 3–5 |
 | Spanish | es | ~930; 98% / ~95% | most | Latin ✅ | no | partial | 1–2 |
 | Hindi | hi | 0 | ❌ | Devanagari shaping via HarfRust, untested; no hyphenation | no | none | 4–6 |
 | Arabic | ar | 0 | ❌ | shaping, joining, lam-alef, bidi ✅ (#207); no kashida; **no mirrored UI** | no | none | 6–8 |
@@ -99,6 +99,9 @@ a thesaurus for Polish, Word's style and clarity refinements, Polish-specific Au
 | Date | Change | Summary |
 |---|---|---|
 | 2026-10-11 | minor | Polish interface (13 languages) and Polish proofing: SJP.PL spelling with suggestions, Polish grammar rules, TeX Polish hyphenation; proofing language per run; dimension ~25% → ~27% |
+| 2026-10-11 | minor | Font dialog sets the Asian text font (`w:eastAsia`) and the Latin text font separately; the Asian list holds the installed Chinese, Japanese and Korean fonts by their interface-language names (#505) |
+| 2026-10-11 | minor | Font list shows installed fonts by their names in the interface language (宋体 for SimSun in Chinese, Japanese and Korean names likewise) and finds them by either name; a Chinese, Japanese or Korean font is stored as `w:eastAsia` too (#505) |
+| 2026-10-11 | minor | Chinese/Japanese interface fonts: a test checks every catalog character has a glyph; an installed CJK font follows the embedded faces whenever they miss one; macOS font asset folders searched for PingFang (#486) |
 | 2026-10-10 | minor | Russian interface (#300; 1,524 entries, built-in style names shown translated; covers everything the interface audit finds) |
 | 2026-10-11 | minor | Turkish interface catalog (1,307 entries), locale selection, saved preference, Turkish casing in command search and font coverage checks; catalog sizes re-counted |
 | 2026-10-11 | trivial | English spelling (#520): our supplement `assets/spelling/en-extra.txt` adds ~220 common modern words the Moby list lacks ("desktop", "download", "email"…) |
diff --git a/docs/parity-checklist.md b/docs/parity-checklist.md
index b0932f6bd1..dfb3f2dd3a 100644
--- a/docs/parity-checklist.md
+++ b/docs/parity-checklist.md
@@ -2,29 +2,33 @@
 
 Generated by `cargo xtask parity` (`wordcraft-cli parity --markdown`): the word-processor feature catalog (`crates/engine/src/catalog.rs`) compared with the live command registry.
 
-**429 of 451 catalog features have commands (95.1%).**
+**483 of 498 catalog features have commands (97.0%).**
 
 | Tab | Live | Total |
 |---|---|---|
-| File | 20 | 20 |
+| File | 21 | 21 |
 | Quick Access | 4 | 4 |
-| Home | 101 | 102 |
-| Insert | 45 | 53 |
-| Draw | 6 | 11 |
+| Home | 102 | 103 |
+| Insert | 47 | 53 |
+| Draw | 10 | 11 |
 | Design | 10 | 10 |
-| Layout | 21 | 21 |
-| References | 24 | 24 |
+| Layout | 22 | 22 |
+| References | 25 | 25 |
 | Mailings | 17 | 17 |
-| Review | 28 | 30 |
+| Review | 29 | 31 |
 | View | 25 | 29 |
+| Developer | 11 | 11 |
 | Table Design | 8 | 8 |
-| Table Layout | 31 | 31 |
+| Table Layout | 32 | 32 |
 | Equation | 21 | 22 |
+| Outlining | 13 | 13 |
 | Picture Format | 14 | 14 |
-| Shape Format | 6 | 6 |
+| Shape Format | 11 | 11 |
+| SmartArt Design | 7 | 7 |
+| Chart Design | 5 | 5 |
 | Header & Footer | 5 | 5 |
 | Editing | 38 | 38 |
-| Tools | 5 | 6 |
+| Tools | 6 | 6 |
 
 ## Missing
 
@@ -36,8 +40,6 @@ Generated by `cargo xtask parity` (`wordcraft-cli parity --markdown`): the word-
 
 - Illustrations › Online Pictures (`insert.onlinePicture`)
 - Illustrations › 3D Models (`insert.model3d`)
-- Illustrations › SmartArt (`insert.smartArt`)
-- Illustrations › Chart (`insert.chart`)
 - Illustrations › Screenshot (`insert.screenshot`)
 - Add-ins › Get Add-ins (`addins.get`)
 - Media › Online Video (`insert.video`)
@@ -45,11 +47,7 @@ Generated by `cargo xtask parity` (`wordcraft-cli parity --markdown`): the word-
 
 ### Draw
 
-- Tools › Lasso Select (`draw.lasso`)
-- Pens › Add Pen (`draw.addPen`)
-- Convert › Ink to Shape (`draw.inkToShape`)
 - Convert › Ink to Math (`draw.inkToMath`)
-- Replay › Ink Replay (`draw.replay`)
 
 ### Review
 
@@ -67,7 +65,3 @@ Generated by `cargo xtask parity` (`wordcraft-cli parity --markdown`): the word-
 
 - Tools › Ink Equation (`insert.inkEquation`)
 
-### Tools
-
-- Templates › Templates and Add-ins (`tools.templates`)
-
diff --git a/docs/roadmap.md b/docs/roadmap.md
index 257c300759..785c1161fa 100644
--- a/docs/roadmap.md
+++ b/docs/roadmap.md
@@ -12,7 +12,8 @@ Opus 5.5 agent wall-clock.
    (Clipboard pane #264, Manage Styles #270, Group #267), fix field bugs (Hebrew RTL #20, IME
    fixes #155–#164) or add languages (de, nb, nn, he). Owner review needed.
 2. **DOCX real-world corpus** (gap #1, 30–50 h): collect openly licensed real-world .docx files,
-   open/render/round-trip them, compare with Word locally, fix what breaks.
+   open/render/round-trip them, compare with Word locally, fix what breaks. Omitted/empty
+   paragraph defaults now have synthetic save/reopen coverage; the corpus gate remains open.
 3. **Preserve what we can't render** (gap #2, 10–15 h): charts, SmartArt, OLE, ink, group shapes
    survive a round trip and show their fallback pictures.
 4. **Stability sweep** (gap #3, 20–30 h): the open crash, hang and write-failure issues, plus an
@@ -55,7 +56,7 @@ partial rows are fidelity gaps (beta work), not broken workflows. WordCraft stay
 | M8 | View | mostly done; window commands missing | 3–5 h |
 | M9 | Mailings | done (first version); Excel/Outlook data sources and email merge missing | 6–10 h |
 | M10 | File/Backstage | mostly done; native printing, Options depth missing | 12–20 h |
-| M11 | Draw and objects | text wrap, text boxes, canvas handles, rotation (#332), ink pens and eraser (#307), contour wrap (#354) done; lasso and ink conversion, grouping missing | 35–55 h |
+| M11 | Draw and objects | text wrap, text boxes, canvas handles, rotation (#332), ink pens and eraser (#307), contour wrap (#354), lasso, Add Pen, Ink to Shape and Ink Replay (#395) done; Ink to Math, grouping missing | 35–55 h |
 | M12 | Formats breadth (PDF, ODT, RTF, HTML, MD, TXT, LaTeX, `.doc` import) | done (first versions); `.doc` write, encryption, minor formats missing | 60–100 h |
 | M13 | Performance budgets | on track (1.4 ms relayout); large real-world documents unmeasured | 10–20 h |
 | M14 | 1.0 polish, packaging, signing | releases v0.1.0–v0.4.0 published (signed macOS, Windows MSI x64/x86/arm64, Linux, FreeBSD, web) | — |
@@ -76,9 +77,11 @@ languages, screen-reader access, ecosystem decisions (VBA, add-ins, cloud), an i
 | 2026-10-11 | trivial | M11: contour (Tight/Through) wrap done (#354) |
 | 2026-10-11 | trivial | M6: the eight missing bibliography styles landed (#383) |
 | 2026-10-11 | trivial | M7: formatting revisions landed (#41) |
+| 2026-10-11 | trivial | Omitted `w:pPrDefault` stays omitted across saves; explicit empty/default properties and later spacing edits remain writable. Synthetic preservation checks only; readiness estimates unchanged |
 | 2026-10-10 | trivial | M5: Draw Table and Eraser landed (#303) |
 | 2026-10-10 | trivial | Merged main: PRs that landed removed from the Current focus list |
 | 2026-10-10 | minor | Current focus heading back to ~150–230 h to beta: full number restored to the additive weighted sum (~60%), method aligned with the standard, no new evidence |
 | 2026-10-10 | minor | Alpha gate table added (core-workflow gate from the progress-docs standard): all six workflows pass, stage stays alpha |
 | 2026-10-10 | major | Created: milestones moved from ROADMAP.md with remaining hours; Current focus from gaps.md; M15–M16 added |
 | 2026-10-10 | trivial | M11: ink pens and eraser landed (#307) |
+| 2026-10-11 | trivial | M11: lasso, Add Pen, Ink to Shape and Ink Replay landed (#395) |
diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md
index d5dc5de353..79c94d6950 100644
--- a/docs/target-app-parity.md
+++ b/docs/target-app-parity.md
@@ -13,7 +13,7 @@ The generated ribbon checklist is [`parity-checklist.md`](parity-checklist.md).
 
 | Number | Value | Kind |
 |---|---|---|
-| Ribbon/menu catalog coverage | **429 / 451 (95.1%)** | **measured**: `cargo xtask parity` (re-derived this pass from `crates/engine/src/catalog.rs` against every `CommandSpec::new` id in the source; identical to the checked-in `parity-checklist.md`) |
+| Ribbon/menu catalog coverage | **483 / 498 (97.0%)** | **measured**: `cargo xtask parity` (re-derived this pass from `crates/engine/src/catalog.rs` against every `CommandSpec::new` id in the source; identical to the checked-in `parity-checklist.md`) |
 | Feature breadth (weighted, beyond the ribbon: dialog options, citation styles, proofing languages, chart types, UI languages) | **~80%** | estimated |
 | Feature depth (weighted by use, table below) | **~68%** | estimated |
 | **Ready for real work** (full target) | **~60%** (range 55–63%) | estimated: weighted sum over the dimension table ([By dimension](#by-dimension)) |
@@ -60,22 +60,24 @@ full parity for the area.
 | Character and paragraph formatting | 11 | 82% | 85% | 8–12 | Nearly every property, Font/Paragraph dialogs, character border, Phonetic Guide (#288), Enclose Characters (#297). Missing: Asian Typography, kerning/ligature/stylistic-set options in the Font dialog's Advanced tab. |
 | Styles and themes | 8 | 74% | 75% | 8–12 | Gallery, pane, create/modify, style sets, themes. Style Inspector landed (#236). Missing: Manage Styles (#270 open), style separators, linked-style edge cases; Word ships 11 Quick Style sets plus dozens of themes, we ship our own smaller set. |
 | Lists | 6 | 78% | 75% | 5–8 | Bullets, numbering, multilevel, restart, `w:lvlOverride` levels (#134), Word's list AutoFormat and Enter/Backspace behaviour. Missing: Define New Multilevel List dialog depth, list styles, legal numbering edge cases. |
-| Tables | 8 | 76% | 72% | 10–16 | Merge/split, styles (cell text takes style formatting, #104), custom table styles saved in the .docx (#256), Word 2013 edge, floating tables, rows split across pages, sort, formula, cell gridlines (#243), Draw Table and Eraser (#303). Missing: splitting or erasing around vertically merged cells, nested-table polish, interactive column resize (#49 open, #217). Cell text direction landed (#245). |
-| Page layout and sections | 7 | 70% | 72% | 12–20 | Margins, size, columns, breaks, page borders, line numbers, vertical alignment, drop caps, hyphenation. Columns don't balance; no vertical text; RTL sections missing. Detail: [layout-parity.md](layout-parity.md). |
+| Tables | 8 | 76% | 72% | 10–16 | Merge/split, styles (cell text takes style formatting, #104), custom table styles saved in the .docx (#256), Word 2013 edge, floating tables, rows split across pages, sort, formula, cell gridlines (#243), Draw Table and Eraser (#303). Missing: splitting or erasing around vertically merged cells, nested-table polish, table column markers on the ruler (#49). Dragging column and row borders and the resize handle on the page landed (#217); cell text direction landed (#245). |
+| Page layout and sections | 7 | 70% | 72% | 12–20 | Margins, size, columns, breaks, page borders, line numbers, vertical alignment, drop caps, hyphenation. Columns don't balance; RTL sections missing. Vertical sections (tbRl/btLr) landed (#491). Detail: [layout-parity.md](layout-parity.md). |
 | Headers, footers, page numbers, fields | 5 | 70% | 70% | 8–12 | First/even/odd, link to previous, TOC as an updatable field (#52), cross-references to real bookmarks (#227). Field coverage is a subset of Word's ~90 field codes; Field dialog missing. |
 | Footnotes and endnotes | 3 | 60% | 60% | 3–5 | Placed and editable, numbers from Word files (#103); long notes continue onto the next page under the continuation separator (#352). Footnote and Endnote dialog with options per section: below text, end of section, number format, start at, restart each section or page, custom mark, convert (#385). |
-| References (TOC, citations, bibliography, captions, index, TOA) | 5 | 65% | 60% | 12–20 | Working first versions, Zotero integration (#189), Zotero/Mendeley `ADDIN` fields round-trip. All 12 of Word's bibliography styles (APA, MLA, Chicago, IEEE, Harvard, ISO 690 author-date and numerical, Turabian, GB/T 7714, GOST name and title sort, SIST02; #383); source manager depth; bibliography sources not yet in DOCX (#169 open). |
-| Review (proofing UI, comments, track changes, compare, protect) | 8 | 72% | 75% | 15–25 | Comment balloons, tracked insert/delete incl. paragraph marks (#244, #125), compare, restrict editing. Formatting revisions (#41): kept in DOCX, recorded while tracking, accepted/rejected, "Formatted: …" balloons and change bars. Moves (#400): kept in DOCX, recorded on a tracked cut and paste, accepted/rejected at either end, green markup and "Moved from/to" balloons. Missing: drag-and-drop moves, insert/delete balloons, Translate, Block Authors, modern comment threads/mentions. Lowered: these gaps are confirmed by source (no `rPrChange` anywhere). |
+| References (TOC, citations, bibliography, captions, index, TOA) | 5 | 65% | 60% | 12–20 | Working first versions, Zotero integration (#189), Zotero/Mendeley `ADDIN` fields round-trip. Caption, Index, Mark Entry, Custom TOC and Create/Edit Source dialogs; updates honour the TOC (`\o \u \t \f \n \p \h`), INDEX (`\c \e \h \r`), XE (`\b \i \t \r`) and SEQ/STYLEREF chapter switches (#402). All 12 of Word's bibliography styles (APA, MLA, Chicago, IEEE, Harvard, ISO 690 author-date and numerical, Turabian, GB/T 7714, GOST name and title sort, SIST02; #383); bibliography sources not yet in DOCX (#169 open). |
+| Review (proofing UI, comments, track changes, compare, protect) | 8 | 72% | 75% | 15–25 | Comment balloons, tracked insert/delete incl. paragraph marks (#244, #125), Compare / Combine with comparison settings (case, white space, formatting, tables, word or character level, #412), Restrict Editing pane with formatting and editing restrictions, exceptions for everyone and a password (#412). Formatting revisions (#41): kept in DOCX, recorded while tracking, accepted/rejected, "Formatted: …" balloons and change bars. Moves (#400): kept in DOCX, recorded on a tracked cut and paste, accepted/rejected at either end, green markup and "Moved from/to" balloons. Show revisions in balloons takes tracked deletions in the body out of the text into "Deleted: …" balloons (insertions stay inline, as in Word; deletions in headers, footers, notes and text boxes, and in print and PDF, stay inline). Missing: drag-and-drop moves, insert/delete balloons, Translate, Block Authors, modern comment threads/mentions. Lowered: these gaps are confirmed by source (no `rPrChange` anywhere). |
 | Proofing (spelling, grammar, thesaurus, languages) | 5 | 40% | (in Review) | 20–40 | English and Polish, chosen per run from its language (`w:lang`): English word list (Moby plus our supplement of modern words such as "desktop", #520) and rule-based grammar; Polish against the installed Hunspell dictionary through a Hunspell-style affix engine, Polish grammar rules and TeX hyphenation patterns (2026-10-10). Other languages are left unmarked. Word ships 120 proofing tools for ~50 languages plus Editor (style refinements, similarity). Issues #25, #40, #100. |
+| Mailings | 2 | 70% | 70% | 6–10 | Mail merge from CSV, fields, rules (IF, SKIPIF, NEXT, NEXTIF, evaluated alike in preview and merge), fields in headers/footers (one section per letter), preview, envelopes, labels. Select Recipients takes a typed list or CSV (#247); no Excel/Outlook/Contacts data sources, no email merge. |
+| Pictures, shapes, text boxes, WordArt | 6 | 60% | 60% | 20–30 | Insert, crop, recolour, styles, floating placement like Word (#136), wrap (square/top-bottom/behind/front), text boxes edit and overflow (#46), VML text boxes (#242), free rotation and flips with a rotation handle (#332), WordArt: text fill (solid, gradient, none), outline, shadow, glow and reflection with our own styles, and Transform warps along arch, circle, wave, slant, inflate/deflate, chevron and triangle (other presets kept and drawn flat), connectors (straight, elbow, curved, arrowheads) glued to shapes' connection sites and re-routed when those move (#416). Missing: tight/through contour wrap, rotated text-box text, group (#267 open), shape effects, WordArt 3-D/bevel and editing text in its bent form, connector routing around shapes, Drawing Canvas, Icons, online pictures, screenshot. |
 | Mailings | 2 | 70% | 70% | 6–10 | Mail merge from CSV, fields, rules (IF, SKIPIF, NEXT, NEXTIF, evaluated alike in preview and merge), fields in headers/footers (one section per letter), preview, envelopes, labels. Select Recipients takes a typed list, CSV (#247) or a sheet of an Excel (.xlsx/.xlsm) or OpenDocument (.ods) workbook, with Select Table to pick the sheet (#334); no Outlook/Contacts/Access data sources, no email merge. |
 | Pictures, shapes, text boxes, WordArt | 6 | 60% | 60% | 20–30 | Insert, crop, recolour, styles, floating placement like Word (#136), wrap (square/top-bottom/behind/front), text boxes edit and overflow (#46), VML text boxes (#242), free rotation and flips with a rotation handle (#332), text-box text direction (90°, 270°, stacked), Align Text and linked text boxes (#369), Icons: an original icon library drawn in code with a searchable picker, inserted as pictures and recoloured with Icon Color (#309), Drawing Canvas with Fit/Expand/Scale and DOCX `wpc:wpc` (#344; members edited by command, not yet dragged inside the canvas; the canvas rotates and flips as a whole). Missing: tight/through contour wrap, text in a freely rotated text box, group (#267 open), shape effects, WordArt, connectors, online pictures, screenshot. |
 | Equations | 1 | 75% | 20% (with Draw) | 4–8 | OMML read/write, OpenType MATH layout, in-place editor with an Equation tab (#191). Missing: line breaking of long display equations, ink equations. |
-| Charts, SmartArt, Draw/ink, 3D models, icons | 4 | 3% | (20% with equations) | 70–110 | Icons landed (#309; an original library drawn in code). Draw: pens, pencil, highlighter, stroke eraser and Hide Ink (#307), ink saved as DrawingML freeforms; lasso, ink to shape/math and replay missing; charts and SmartArt are dropped on DOCX read (no `c:chart`/`dgm` handling in `crates/docx`). |
-| View (modes, zoom, panes, windows) | 3 | 72% | 70% | 6–10 | Print/web/draft/read/focus, dark page (#194), pages side by side when zoomed out (#251), navigation pane. Missing: View Side by Side, Synchronous Scrolling, Arrange All, Switch Windows, Outline view depth, Immersive Reader depth. |
+| Charts, SmartArt, Draw/ink, 3D models, icons | 4 | 3% | (20% with equations) | 70–110 | Icons landed (#309; an original library drawn in code). Draw: pens, pencil, highlighter, stroke eraser and Hide Ink (#307), ink saved as DrawingML freeforms; Lasso Select (move, recolour, delete), Add Pen gallery, Ink to Shape (line, rectangle, ellipse, triangle, polygon) and Ink Replay (#395); Ink to Math, pressure and Word's own InkML missing; charts: Insert › Chart makes column, bar (clustered and stacked), line, area, pie, doughnut and scatter charts with Chart Design (change type, Edit Data grid, title, legend, data labels) and saves them as real chart parts (#409); charts from Word are drawn (#292) and kept on save (#319) but stay read-only; SmartArt is drawn and kept (#292, #319); Insert › SmartArt (#497) creates and edits list, process, cycle, hierarchy, pyramid, radial, matrix and Venn graphics with our own layouts, a Text Pane and the SmartArt Design tab, saved as diagram parts with the drawing; SmartArt from other programs stays read-only. |
+| View (modes, zoom, panes, windows) | 3 | 72% | 70% | 6–10 | Print/web/draft/read/focus, dark page (#194), pages side by side when zoomed out (#251), navigation pane; Outline view with the Outlining tab: levels, promote/demote, moving with collapsed content, expand/collapse, Show Level, first line only, text formatting (#493). Missing: View Side by Side, Synchronous Scrolling, Arrange All, Switch Windows, Master Document, Immersive Reader depth. |
 | Backstage, printing, options | 3 | 58% | 55% | 12–20 | New/Home pages (#254), save prompts (#151), web printing via the browser (#209). Desktop printing still goes through PDF; Options has a fraction of Word's panes. |
 | Right-to-left and complex scripts | 1 | 50% | 55% | 15–25 | UAX #9, Arabic shaping, RTL paragraphs (#207). No RTL sections/tables, kashida justification or mirrored UI; open bug reports (#215, #211, #199, #66, #63, #48, #19) need re-testing against #207. |
-| East Asian typography | 1 | 25% | not rated | 13–22 | IME input works (winit fixes pending, #155–#164). Ruby/Phonetic Guide with DOCX round trip (#288); document grid (lines per page, characters per line, #391). No vertical text, `w:eastAsianLayout`, enclose characters, Asian line-break options. |
-| Accessibility | 1 | 35% | not rated | 15–25 | AccessKit enabled in eframe; an accessibility checker exists. Screen-reader access to the document canvas is untested; no alt-text workflow polish, no read-order tools. |
+| East Asian typography | 1 | 25% | not rated | 13–22 | IME input works (winit fixes pending, #155–#164). Vertical text in sections, text boxes and cells with upright ideographs (#491; no `vert` glyph alternates). Ruby/Phonetic Guide with DOCX round trip (#288); document grid (lines per page, characters per line, #391). No `w:eastAsianLayout`, enclose characters, Asian line-break options. |
+| Accessibility | 1 | 50% | not rated | 10–18 | AccessKit enabled in eframe. Alt Text pane for pictures, shapes, text boxes, groups, charts and tables with Mark as decorative, all round-tripping in DOCX (#386). The Accessibility pane groups errors, warnings and tips with jump-to and one-click fixes; rules for alt text, heading order, header rows, blank table rows/columns, merged cells, low contrast (WCAG ratio), floating objects and blank paragraphs. Screen-reader access to the document canvas is still untested (#18); no reading-order tools. The document canvas describes its text, headings, lists, tables, links, pictures and caret to screen readers through AccessKit (#488). |
 | Agent control (CLI, MCP, control channel, macro record/playback) | 0 | beyond Word | 100%+ | — | Every action is a command id usable from CLI, MCP and a keyed control port. Word has VBA and Office.js instead (see Ecosystem). |
 
 Weighted feature depth: **~68%** (Σ weight × parity / 100 over the table).
@@ -103,7 +105,7 @@ h), pictures and tables (12–18 h), spelling depth (8–12 h), polish (10–20
 
 | Discount | Mainstream | Essentials | Evidence |
 |---|---|---|---|
-| Interaction fidelity | ×0.93 | — | Typing pinned to Word (`tests_typing.rs`), ribbon, keytips, mini-toolbar; but 16 modal dialogs against Word's ~100, 125 of ~250 shortcuts, no table column drag on the canvas (#217, #49), picture/shape handling complaints (#82, #142), lines wrap differently without an Aptos-metric font |
+| Interaction fidelity | ×0.93 | — | Typing pinned to Word (`tests_typing.rs`), ribbon, keytips, mini-toolbar; but 16 modal dialogs against Word's ~100, 125 of ~250 shortcuts, picture/shape handling complaints (#82, #142), lines wrap differently without an Aptos-metric font |
 | Discoverability and UI clarity | — | ×0.95 | Word-style ribbon a Word user already knows, command search, keytips; some newer pane strings and tooltips terse or untranslated |
 | Stability on real machines | ×0.90 | ×0.90 (launch and install) | Never-crash standard, hostile-param fuzzing, panic guard; but open startup crash on Intel UHD (#170), freezes (#77, #59, #31), Windows writes fail without admin (#218), installer conflicts with other Crafting Apps (#64, #73, #106, #51); 5 days of field history |
 | Exchanging files with Word users | ×0.90 | ×0.92 (opening files people send) | Word opens our .docx; `.doc` import; but no real-world corpus test, charts/SmartArt/OLE dropped silently, pagination differs (Aptos, no column balancing or footnote continuation). Simple documents, which are most of what a casual user receives, come through well; double-click open on macOS is fixed on main but not yet released (#223, #279) |
@@ -188,7 +190,7 @@ Word. Their weighted sum is the **full ready for real work** number.
 | Dimension | Weight | Parity | Hours to full | Doc | Evidence |
 |---|---|---|---|---|---|
 | Features (depth, table above) | 30% | 68% | 210–335 | this file | Weighted table above. Hours: the area table sums to 290–460 h; the Page layout, Footnotes, RTL and East Asian rows (~50–85 h) are counted under Layout and the Proofing row (25–45 h) under Localization, so they aren't counted twice |
-| File formats (DOCX fidelity first) | 20% | 60% | 185–300 | [file-format-parity.md](file-format-parity.md) | DOCX opens in Word and round-trips our own tests, but no real-world corpus test yet; charts, SmartArt, OLE, content controls (unwrapped) and encrypted files are lost or refused |
+| File formats (DOCX fidelity first) | 20% | 60% | 185–300 | [file-format-parity.md](file-format-parity.md) | DOCX opens in Word and round-trips our own tests, but no real-world corpus test yet; charts, SmartArt, OLE and encrypted files are lost or refused (content controls kept since #381) |
 | Layout and pagination fidelity | 15% | 55% | 90–145 | [layout-parity.md](layout-parity.md) | Aptos has no metric-matched substitute so lines break differently from Word; no column balancing, footnote continuation or document grid; compatibility modes beyond 15 partial |
 | UI/UX fidelity | 10% | 65% | 65–100 | [ui-parity.md](ui-parity.md) | Ribbon, keytips, mini-toolbar, Backstage, 125 shortcuts; 16 modal dialogs against Word's ~100; no ribbon/keyboard customization |
 | Stability | 10% | 50% | 25–45 | [gaps.md](gaps.md) | Never-crash standard and hostile-param fuzzing in place, but open reports of a startup crash on Intel UHD (#170), freezes (#77, #59, #31) and Windows write failure without admin (#218); no soak test; 5 days of field history |
@@ -250,6 +252,17 @@ can be used without committing Word output.
 | Date | Change | Summary |
 |---|---|---|
 | 2026-10-11 | minor | Polish interface (13 UI languages) and Polish proofing with per-run languages: Proofing 35% → 40% (25–45 h → 20–40 h), Localization 25% → 27%; feature depth and readiness unchanged at this precision |
+| 2026-10-11 | trivial | Tables: column and row borders and the resize handle drag on the page (#217); Tables row and interaction-fidelity evidence updated, no percentage change |
+| 2026-10-11 | trivial | Review: Show revisions in balloons takes tracked deletions in the body out of the text into "Deleted: …" balloons (it drew like the comments-and-formatting mode before); Review row updated, no percentage change |
+| 2026-10-11 | trivial | Insert › SmartArt (#497): charts/SmartArt row updated; catalog 429/451 → 437/458 (95.4%); no percentage change |
+| 2026-10-11 | trivial | Outline view depth (#493): View row updated; catalog 428/450 → 441/463 (95.2%) with the Outlining tab rows |
+| 2026-10-11 | trivial | Screen readers can read the document canvas (#488): Accessibility row updated; no percentage change |
+| 2026-10-11 | trivial | Compare settings, Restrict Editing pane and AutoCorrect Options (#412): Review row updated; no percentage change |
+| 2026-10-11 | trivial | Pictures, shapes, text boxes, WordArt: WordArt text effects and Transform warps, connectors glued to shapes (#416); catalog 423/448 → 428/453 (94.5%); no percentage change |
+| 2026-10-11 | trivial | Content controls kept, shown and edited, Developer › Controls (#381); catalog +11 rows, all live (402/434 → 413/445, 92.8%); no percentage change |
+| 2026-10-11 | trivial | Insert › Chart (#409): charts row updated, catalog 408/439; no percentage change |
+| 2026-10-11 | trivial | Accessibility 35% → 50%: Alt Text pane for every object and tables, decorative flag, deeper checker with an Accessibility pane (#386); weight 1, headline unchanged |
+| 2026-10-11 | trivial | References: Caption, Index, Mark Entry, Custom Table of Contents and Create/Edit Source dialogs, with the field switches they write honoured on update (#402); no percentage change |
 | 2026-10-11 | trivial | Move tracking (#400): Review row updated; no percentage change |
 | 2026-10-11 | trivial | Footnotes and endnotes: Footnote and Endnote dialog, options per section (position, format, start, restart each section/page), convert notes (#385); no percentage change |
 | 2026-10-11 | trivial | Pictures, shapes, text boxes: text direction, Align Text and linked text boxes (Create Link / Break Link), DOCX `bodyPr` `vert`/`anchor` and `wps:linkedTxbx` (#369); no percentage change |
@@ -264,7 +277,9 @@ can be used without committing Word output.
 | 2026-10-11 | trivial | References: all 12 of Word's bibliography styles (eight more: Harvard, ISO 690 ×2, Turabian, GB/T 7714, GOST ×2, SIST02) (#383); no percentage change |
 | 2026-10-11 | trivial | Mail merge fixes (#427–#430): SKIPIF drops matching records, NEXT advances later fields, IF previews, header/footer fields merge; Mailings row updated, no percentage change |
 | 2026-10-11 | trivial | Formatting revisions (#41): Review row updated; no percentage change |
+| 2026-10-11 | trivial | #395: Lasso Select, Add Pen, Ink to Shape and Ink Replay; catalog 423/448 → 427/448 (95.3%) |
 | 2026-10-10 | trivial | #307: Draw tab pens, eraser and Hide Ink; catalog 384/430 → 390/430 (90.7%) |
+| 2026-10-11 | trivial | Vertical sections (#491): Page layout and East Asian rows updated; no percentage change |
 | 2026-10-10 | trivial | Draw Table and Eraser (#303): catalog 384/430 → 387/430 (90.0%) |
 | 2026-10-10 | trivial | Pictures, shapes, text boxes: free rotation and flips, rotation handle, rotated wrap bounds, DOCX `a:xfrm` rot/flipH/flipV (#332); no percentage change |
 | 2026-10-10 | minor | Merged main (12 PRs): Paste Special, Advanced Find, Column Selection, Style Inspector, custom table styles, gridlines, zoom buttons, touchpad scrolling, File Info fields, Serbian. Catalog 378/428 → 384/430 (89.3%); typing 82→85%, styles 72→74%, tables 74→76%; feature depth 67→68%; mainstream 54→55%; full stays ~60%, essentials ~63% |
diff --git a/docs/typing-parity.md b/docs/typing-parity.md
index cb242663c8..41f37dcdd0 100644
--- a/docs/typing-parity.md
+++ b/docs/typing-parity.md
@@ -1,6 +1,6 @@
 # Typing parity with Word
 
-> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-11 · **Change:** minor (Move Paragraph Up/Down, Promote/Demote, Go Back and Alt+X keys, #343) · **Target:** Microsoft Word (Microsoft 365) for Mac 16.113.4
+> **Last reviewed:** 2026-10-11 · **Last updated:** 2026-10-11 · **Change:** trivial (complex-script caret and Backspace, #604; Move Paragraph Up/Down, Promote/Demote, Go Back and Alt+X keys, #343; previously trivial: outline keys in Outline view, #493) · **Target:** Microsoft Word (Microsoft 365) for Mac 16.113.4
 
 What Word does when you type, observed black-box (same keystrokes typed into Word and
 WordCraft, results read back paragraph by paragraph) and pinned by tests in
@@ -20,15 +20,25 @@ overall picture is in [`target-app-parity.md`](target-app-parity.md).
 | Backspace at the start of an item | 1st: number removed, indent kept; 2nd: Normal paragraph — **not** joined to the one above | `backspace_at_the_start_of_an_item_removes_the_number_then_the_indent` |
 | Enter mid-item / at item start | splits the item / inserts an empty item above | `enter_in_the_middle_or_at_the_start_of_an_item` |
 | Shift+Enter in an item | line break inside the same item | `shift_enter_stays_inside_the_list_item` |
+| Paste: Keep Text Only `A`, empty line, `B` into an empty item | three paragraphs `A`, empty, `B`: pasted paragraph breaks are text, not Enter (they never end the list) | `plain_text_paste_keeps_an_empty_paragraph_in_a_list` |
 | `* ` `- ` `1. ` `1) ` `a. ` `a) ` `A. ` `i. ` `I. ` + text | bullet, dash bullet, 1. 1) a. a) A. i. I. lists | `list_autoformat_triggers` |
+| `> ` `-> ` `=> ` + text | bulleted list with an arrow bullet (➢ ➔ ⇨; Word takes them from a symbol font, we use the Unicode arrows) ¹ | `arrow_bullets` |
 | `1. ` after other text | a new list restarting at 1 (never continues an earlier list) | `typing_1_dot_starts_numbering_again` |
 | ⌘Z right after an AutoFormat | undoes only the AutoFormat (`* ` comes back as text) | `undo_right_after_autoformat_undoes_only_the_autoformat` |
 
+## Undo
+
+| Keys | Word's result | Test |
+|---|---|---|
+| type, select some of it, type over it | two undo steps: the first ⌘Z brings the selected text back (still selected), the second removes the typing. Uninterrupted typing stays one step | `typing_then_selecting_then_typing_are_two_undo_steps` |
+| ⌘B with nothing selected, ⌘Z, type | the text isn't bold (Undo takes the waiting caret formatting back too); ⌘Y brings it back | `undoing_bold_at_the_caret_turns_bold_typing_off_again` |
+
 ## Track Changes
 
 | Keys | Word's result | Test |
 |---|---|---|
 | Enter (tracking on) | the new paragraph mark is a tracked insertion; Reject All joins the paragraphs again, Accept All keeps them | `tracked_enter_and_backspace_track_the_paragraph_mark`, `tests::reject_all_removes_a_tracked_paragraph_break` |
+| Paste of several paragraphs (tracking on) | every paragraph mark the paste adds is a tracked insertion; Reject All restores the one paragraph, Accept All keeps the pasted ones | `reject_all_takes_out_the_paragraph_breaks_a_tracked_paste_inserted` |
 | Backspace at a paragraph start / Delete at a paragraph end (tracking on) | the paragraph mark is marked deleted (still shown); the caret moves before it (Backspace) or past it (Delete). Accept joins the paragraphs, Reject keeps them. A mark you inserted yourself is just removed | `tracked_enter_and_backspace_track_the_paragraph_mark`, `tests::tracked_backspace_and_delete_mark_a_paragraph_break_deleted` |
 
 ## Editing keys
@@ -40,6 +50,8 @@ Windows/Linux keys are given first, macOS second.
 |---|---|---|
 | Alt+Shift+Up / Down (⌃⇧↑ / ⌃⇧↓) | the paragraphs the selection touches swap with the paragraph above / below, keeping style and list membership; the selection moves with them; one undo step. A selection ending at the start of a paragraph doesn't take it along. Refused at the top or bottom of the story or cell, next to a table and across a section break | `alt_shift_down_then_up_moves_a_paragraph_and_back_and_undoes` |
 | Alt+Shift+Left / Right (⌃⇧← / ⌃⇧→) | Promote / Demote: a heading goes up or down one level (Heading 1 and Heading 9 are the ends); promoted body text becomes a heading at the level of the heading before it; a list item changes level like Shift+Tab / Tab | `alt_shift_left_and_right_promote_and_demote_headings_and_list_items` |
+| Outline view: Alt+Shift+Up / Down, Left / Right | as above, but a collapsed heading takes what is hidden under it along: moving passes whole shown paragraphs with their hidden content; promote/demote shifts the hidden subheadings too | `outline_collapse_hides_descendants_and_expand_restores` |
+| Outline view: Alt+Shift+Plus / Minus, Alt+Shift+1–9, Alt+Shift+A | Expand / Collapse the heading (one level at a time); Show Level 1–9; show all levels. The caret never stays in hidden text: it moves on to the next shown paragraph | `outline_show_level_filters_paragraphs` |
 | Shift+F5 | Go Back: the caret cycles through the last four places edited, most recent first | `shift_f5_goes_back_through_the_last_edits` |
 | Alt+X (no macOS default) | the hex code before the caret (up to six digits, `U+` optional) or the selected code becomes its character; otherwise the character before the caret becomes its code (`é` ↔ `00E9`); one undo step | `alt_x_toggles_between_a_character_and_its_code` |
 
@@ -59,23 +71,55 @@ Applied when a word is finished by a space, punctuation **or Enter** (`enter_fin
   paragraphs Enter makes from it aren't links (#413; `a_link_covers_only_its_own_text`,
   `typing_at_either_end_of_a_link_is_not_linked`).
 - Enter after `---` `===` `***` `___` `~~~` `###` → a bottom border on the paragraph above
-  (single, double, dotted, thick, wave, triple) (`border_line_autoformat`).
+  (single, double, dotted, thick, wave, triple) (`border_line_autoformat`). ⌘Z right after brings the
+  characters back and removes the border; the Enter stays (one undo step) ¹
+  (`undo_right_after_a_border_line_brings_the_characters_back`).
+- `+---+------+` Enter (plus signs around runs of hyphens, the whole paragraph) → a one-row
+  table across the text width, each column as wide as its share of the hyphens; the caret goes
+  into the first cell. ⌘Z right after brings the characters back. More than 63 columns stay
+  text ¹ (`plus_and_hyphen_line_becomes_a_table`).
+- Smileys `:)` `:-)` `:(` `:-(` `:|` → ☺ ☹ 😐, also straight after a word (`ok:)` → `ok☺`) ¹
+  (`smileys_are_replaced_inside_words_too`).
+
+- Names of days are capitalised (`monday` → `Monday`). AutoCorrect Options (#412,
+  `tools.autocorrect`, saved per user) switch each of these off: replacements, sentence and
+  table-cell capitals, days, smart quotes, fractions, ordinals, dashes, links, bulleted and
+  numbered lists, border lines; user entries are added, replaced or deleted (built-in ones too),
+  and "don't capitalize after" exceptions extend the abbreviation list. A replacement of several
+  words takes a sentence capital on its first (`autocorrect_options_change_what_typing_does`).
+
+¹ From Word's documented AutoFormat and AutoCorrect options; not yet keystroke-compared with
+Word.
+## Editing options (File › Options › Advanced)
+
+| Keys / setting | Result | Test |
+|---|---|---|
+| Typing over a selection | replaces it (Word's default); with "Typing replaces selected text" off, the text goes in front of the selection, which stays | `typing_over_a_selection_follows_the_replace_selection_option` |
+| Overtype on, typing | each character replaces the one after the caret, never the paragraph mark or an object; Insert switches overtype only with the Insert-key option on (off by default, as in Word) | `overtype_replaces_the_characters_after_the_caret` |
 
 ## Layout
 
 - No line break right after a slash (`and/or`, URLs) unless the word can't fit a line
   (`layout::tests::no_line_break_right_after_a_slash`).
 
+## Complex scripts
+
+- Myanmar, Khmer and the Indic scripts are typed in memory order (consonant, medials, then
+  vowel signs such as ေ, which is drawn before its consonant); the caret steps over whole
+  syllables (Myanmar vowel signs and stacked consonants never split off), Backspace removes one
+  character (vowel sign, medial, stacked consonant), Delete the whole syllable — the platforms'
+  standard behaviour, not yet compared against Word (#604,
+  `myanmar_typing_steps_by_syllable_and_backspaces_by_sign`,
+  `indic_and_khmer_backspace_removes_one_character`).
+
 ## Known gaps
 
 - Word's body font Aptos isn't installed outside Office; our substitute (Carlito, else Helvetica
   Neue) is wider, so lines wrap earlier than in Word. Needs a metric-matched open substitute.
-- `:)` inside a word (`ok:)`) isn't replaced (Word replaces it).
 - Moving paragraphs with Track Changes on isn't recorded as a tracked move; whole table rows
   don't move yet (a selection across cells is refused). Go Back's places aren't mapped through
   later edits (they are clamped to the document).
-- Not yet compared: `+---+---+` Enter (table AutoFormat), `> ` arrow bullets, undo after a
-  border line, Correct TWo INitial CApitals.
+- Not yet compared: Correct TWo INitial CApitals; the rows marked ¹ above.
 
 ## How to compare
 
@@ -91,6 +135,13 @@ Applied when a word is finished by a space, punctuation **or Enter** (`enter_fin
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | minor | AutoFormat tables from `+---+`, arrow bullets, smileys inside words, undo after a border line (#546) |
+| 2026-10-11 | trivial | Outline view keys: expand/collapse, Show Level, moving and promoting with collapsed content (#493) |
+| 2026-10-11 | minor | Editing options: typing replaces selection, overtype and the Insert key (#485) |
+| 2026-10-11 | minor | Pasted paragraph breaks: tracked under Track Changes (#417), kept in a list by Keep Text Only (#422) |
+| 2026-10-11 | minor | Complex scripts: caret by syllable, Backspace by character (#604) |
+| 2026-10-11 | minor | Undo rows: a selection ends the typing group (#419); Undo of Bold at the caret restores unbolded typing (#424) |
+| 2026-10-11 | minor | Names of days capitalised; AutoCorrect Options (user entries, deleted built-ins, exceptions, every AutoCorrect/AutoFormat switch) change typing (#412) |
 | 2026-10-11 | minor | Editing keys: Move Paragraph Up/Down, Promote/Demote, Go Back (Shift+F5), Alt+X (#343) |
 | 2026-10-11 | minor | Hyperlinks: text typed at either end of a link or after Enter stays outside it (#413) |
 | 2026-10-10 | trivial | Status line, revision history and cross-links added (progress-docs standard) |
diff --git a/docs/ui-parity.md b/docs/ui-parity.md
index 5237ba092d..59450e7c36 100644
--- a/docs/ui-parity.md
+++ b/docs/ui-parity.md
@@ -6,44 +6,77 @@ How WordCraft looks and feels next to Word: ribbon, dialogs, panes, keyboard, mo
 Typing behaviour has its own checklist ([`typing-parity.md`](typing-parity.md)). All assets are our
 own (`AGENTS.md`: no Microsoft iconography, ever).
 
-**Dimension: ~65% (estimated), 65–100 h to full** (the sum of the rows below; dialog depth is counted here, not under features).
+**Dimension: ~65% (estimated), 61–94 h to full** (the sum of the rows below; dialog depth is counted here, not under features).
 
 | Area | WordCraft | Word | Parity | Hours |
 |---|---|---|---|---|
-| Ribbon tabs and groups | All Word tabs including contextual Table Design/Layout, Picture Format, Shape Format, Header & Footer, Equation; ribbon overflow (#43, #129). Draw tab: Select, Eraser, Pen, Pencil, Highlighter with colour and thickness (#307); missing: Lasso, Add Pen, Ink to Shape/Math, Ink Replay | Same plus Draw | 85% | (Draw in features) |
+| Ribbon tabs and groups | All Word tabs including contextual Table Design/Layout, Picture Format, Shape Format, Header & Footer, Equation, Outlining (Outline view, #493); ribbon overflow (#43, #129). Draw tab: Select, Eraser, Pen, Pencil, Highlighter with colour and thickness (#307); Lasso (drag to move, Delete, recolour), Add Pen gallery (right-click to remove), Ink to Shape, Ink Replay with play/pause/rewind/forward bar (#395); missing: Ink to Math | Same plus Draw | 85% | (Draw in features) |
 | Keytips (Alt / ⌃⌥ letters) | ✅ (#43) | ✅ | 85% | 1–2 |
+| Mini-toolbar on selection | ✅ (#43, two rows #535) | ✅ | 80% | 1–2 |
 | Mini-toolbar on selection | ✅ (#43) | ✅ | 80% | 1–2 |
+| Colour drop-downs: theme/standard colours, Recent Colors, More Colors… → Colors dialog (Standard honeycomb, Custom hue/saturation field with lightness, RGB/HSL and hex) | ✅ Font Color (ribbon, mini toolbar, Font dialog), Shading, Page Color, Shape Fill/Outline/Glow, pen colours, dialog colour fields (#606); no Gradient or eyedropper | ✅ | 90% | 1 |
 | Quick Access Toolbar | AutoSave, then the user's commands (Save, Undo, Redo by default); add, remove and reorder from its … menu (common commands, More Commands…), right-click on any ribbon button, or Customize Ribbon; saved per user (#379, #376). Not shown below the ribbon | customizable | 90% | 0.5 |
 | Customize Ribbon / Customize Keyboard | Customize Keyboard (#368): categories, a command's keys, press a combination to see which command uses it, Assign / Remove / Reset All; custom keys override built-ins, removed built-ins do nothing, saved per user; `tools.customizeKeyboard` for agents. Customize Ribbon (#379): show, hide and reorder tabs, custom tabs and custom groups (on any tab) holding any commands, rename, remove, Reset; right-click on the ribbon; saved per user; `tools.customizeRibbon` for agents. Built-in tabs can't be renamed; no import/export file | ✅ | 85% | 1–2 |
-| Keyboard shortcuts | **125** commands bound in `CommandSpec::key`, 144 key combinations (measured on Linux/Windows); styles, spacing, symbols, fields, views, mail merge (#330); field keys Alt+F9, Shift+F9, Ctrl+Shift+F9, Ctrl+F11, Ctrl+Shift+F11, F11, Shift+F11 (#339); Alt+Shift+arrows (move paragraphs, promote/demote), Shift+F5 Go Back and Alt+X (#343). Missing: en dash on the numeric keypad | ~250 default shortcuts | ~70% | 2–4 |
-| Modal dialogs | **38** (`Dialog` enum: Font, Enclose Characters, Paragraph, Tabs, Borders and Shading, Find, Go To, Insert Table, Table Properties, Page Setup, Link, Bookmark, Word Count, Zoom, Watermark, New Style, Modify Style, Manage Styles, Table Style, Commands, Icons, Paste Special, About, Save Changes, Password, Encrypt with Password, Define New Multilevel List, Track Changes Options; Columns, Symbol with Special Characters, Field (#321); Field code (#339); mail merge Recipients, Insert Merge Field, Find Recipient, Rules, Match Fields, Check for Errors) plus panes and menus for the rest | ~100 (Caption, Index, TOC options, Citation, Compare, Protect, Language, Hyphenation, Line Numbers, Envelopes, Labels, AutoCorrect, Options panes…) | ~40% | 20–30 |
-| Task panes (Navigation, Styles, Comments, Reviewing, Format Picture/Shape, Thesaurus, Accessibility, Clipboard, Selection) | Navigation, Styles, Comments, Thesaurus, Accessibility, Read Aloud, Zotero; Style Inspector (#236); Clipboard pane (#264) open | all | 70% | 4–6 |
-| Context menus (right-click) | text, spelling suggestions, fields (Update Field, Edit Field…, Toggle Field Codes, #339); objects and tables partial | rich per context | 55% | 3–5 |
-| Backstage (Home, New, Open, Info, Save As, Print, Share, Export, Options) | Home and New separate (#254), Info properties kept (#268) | | 68% | 4–6 |
+| Keyboard shortcuts | **137** commands bound in `CommandSpec::key`, 156 key combinations (measured on Linux/Windows); styles, spacing, symbols, fields, views, mail merge (#330); field keys Alt+F9, Shift+F9, Ctrl+Shift+F9, Ctrl+F11, Ctrl+Shift+F11, F11, Shift+F11 (#339); Alt+Shift+arrows (move paragraphs, promote/demote), Shift+F5 Go Back and Alt+X (#343); Outline view: Alt+Shift+Plus/Minus expand/collapse, Alt+Shift+1–9 and Alt+Shift+A Show Level (#493). Missing: en dash on the numeric keypad | ~250 default shortcuts | ~70% | 2–4 |
+| Modal dialogs | **54** (`Dialog` enum: Font, Enclose Characters, Paragraph, Tabs, Borders and Shading, Find, Go To, Insert Table, Table Properties, Page Setup, Link, Bookmark, Word Count, Zoom, Watermark, New Style, Modify Style, Manage Styles, Table Style, Commands, Icons, Templates and Add-ins, Organizer, Compare and Combine, AutoCorrect Options, Paste Special, About, Save Changes, Password, Encrypt with Password, Define New Multilevel List, Track Changes Options; Columns, Symbol with Special Characters, Field (#321); Field code (#339); mail merge Recipients, Insert Merge Field, Find Recipient, Rules, Match Fields, Check for Errors; Caption with New Label and Numbering, Index, Mark Index Entry, Custom Table of Contents with Options and TOC styles, Source Manager, Create/Edit Source (#402); Line Numbers, Hyphenation with Manual Hyphenation, Language, Envelopes, Labels (#407)) plus panes and menus for the rest | ~100 (Options panes…) | ~45% | 11–19 |
+| Task panes (Navigation, Styles, Comments, Reviewing, Format Picture/Shape, Thesaurus, Accessibility, Clipboard, Selection) | Navigation, Styles, Comments, Thesaurus, Restrict Editing, Accessibility (grouped findings, jump-to, fixes) and Alt Text (#386), Read Aloud, Zotero; Style Inspector (#236); Clipboard pane (#264) open | all | 70% | 4–6 |
+| Context menus (right-click) | text, spelling suggestions, fields (Update Field, Edit Field…, Toggle Field Codes, #339); right-click selects a picture, shape or text box and offers Wrap Text (styles, Move with Text / Fix Position on Page, #513); tables partial | rich per context | 60% | 3–5 |
+| Backstage (Home, New, Open, Info, Save As, Print, Share, Export, Options) | Home and New separate (#254), Info properties kept (#268), Options in Word's panes with working settings (#485), Print page with preview, page range and copies (#641) | | 68% | 4–6 |
 | Rulers: indents, tabs, margins, table columns | indents draggable (one undo, #62); tabs; table column drag pending (#49) | ✅ | 70% | 2–3 |
 | On-canvas objects: select, drag, resize handles, nudge | ✅ tested (#228) | ✅ | 75% | — |
+| Tables on the page: drag column and row borders, resize handle past the bottom-right corner | ✅ resize cursors, dashed guide, one undo step per drag, selection kept; Shift moves one column; Esc cancels (#217). Missing: Ctrl and Alt drags, the left edge, borders of selected cells only, double-click AutoFit | ✅ | 80% | 1–2 |
 | Rotation handle, crop handles on canvas, alignment guides, smart guides | rotation handle (Shift: 15° steps), turned frames resize along their axes (#332); crop handles and guides missing | ✅ | 25% | 3–5 |
-| Selection: word/sentence/paragraph clicks, Shift extend, F8 extend mode, column (Alt+drag, #237) | ✅ | ✅ | 85% | 1 |
+| Selection: word/sentence/paragraph clicks, dragging after a double-click/triple-click/Ctrl+click extends by whole words/paragraphs/sentences (#549), Shift extend, F8 extend mode, column (Alt+drag, #237) | ✅ | ✅ | 90% | 1 |
 | Zoom: Ctrl+scroll, pinch (#179), zoom buttons (#232), pages side by side when zoomed out (#251) | ✅ | ✅ | 85% | — |
 | Touchpad smooth/inertial scroll | ✅ (#252) | ✅ | 90% | — |
 | Status bar (page x of y, words, language, view buttons, zoom slider) | ✅ (the language is the caret's; a click sets the proofing language) | ✅ | 85% | — |
+| Caret motion: keys and typing glide the caret to its new place (100 ms, `cubic-bezier(0, 0, 0, 1)`), the blink fades (530 ms on and off, 100 ms fades); clicks and scripted moves don't glide. File › Options › Advanced › Animation (`ui.caretAnimation`) turns it off | ✅ as measured from Word for Windows (`caret_glide.rs`); zoom levels other than 100%, modifier keys and off-screen moves not measured | ✅ on Windows; Word for Mac not measured | 90% | 1–2 |
 | Interface themes (light, dark, system #249, follows OS changes live #311), dark page separate from the interface theme (#194, #312) | ✅ | ✅ | 90% | — |
 | Interface size (File › Options › General, 80–200 %, on top of the system display scale; `ui.interfaceSize`) (#475) | ✅ | system display scaling only | 100% | — |
+| Animation effects (File › Options › Accessibility: Use system setting, On, Off; `ui.animations`). Off: a wheel notch scrolls at once; Ctrl+wheel zooms in whole steps, each drawn finished in its own frame (a notch at once; touchpad pinches and high-resolution wheels in steps of about 10% rather than gliding); menus, buttons and the scroll to the caret neither fade nor glide | ✅ "Use system setting" reads Windows (Animation effects), macOS (Reduce motion), the Linux/BSD desktops (settings portal: the cross-desktop reduced-motion preference, GNOME's switch, KDE's animation speed; the GTK and KDE settings files where no portal answers) and browsers (`prefers-reduced-motion`), and follows a change while running. Run on Windows and against a stand-in portal on Linux; not yet tried on a Mac or a real GNOME or KDE session | not compared | 90% | 0.5–1 |
+| File dialogs (Open, Save As, Export, Insert Picture) | system dialog, without blocking the window (#94); Linux/BSD without a file chooser portal or zenity: WordCraft's own browser, also File › Open › Browse in WordCraft… (#576) | system dialog | 95% | — |
 | Platform conventions (macOS menus/traffic lights #255, Windows title bar, Linux CSD on Wayland #78) | partial | native | 70% | 3–5 |
-| Screen readers (VoiceOver, Narrator, Orca) | AccessKit on, document canvas exposure untested | full | 25% | 10–15 |
+| Screen readers (VoiceOver, Narrator, Orca) | AccessKit on; the document canvas describes paragraphs, headings (level), list items, tables, links, pictures (alt text) and the caret and selection, for the pages on screen (#488); not yet tried with real screen readers | full | 50% | 5–8 |
 | Right-to-left (mirrored) interface | ❌ | ✅ (Arabic, Hebrew Word) | 0% | in localization |
 
 ## Revision history
 
 | Date | Change | Summary |
 |---|---|---|
+| 2026-10-11 | trivial | Tables on the page: column and row borders and the resize handle drag, with a dashed guide and one undo step per drag (#217) |
+| 2026-10-11 | trivial | Animation effects › Use system setting also reads macOS (Reduce motion) and the Linux/BSD desktops (settings portal: the cross-desktop reduced-motion preference, GNOME's switch, KDE's animation speed; the GTK and KDE settings files where no portal answers), and follows a change without a restart |
+| 2026-10-11 | trivial | Animation effects setting in File › Options › Accessibility (Use system setting, On, Off), kept between runs: the app eased wheel scrolling, zooming and its fades whatever the system's setting was; off, they land at once. Follows the system's setting on Windows and in browsers; `ui.animations` for agents |
+| 2026-10-11 | trivial | Built-in file browser when the system file dialog can't be shown on Linux/BSD; `ui.fileBrowser` (#576) |
+| 2026-10-11 | trivial | Every measurement now follows File › Options › Advanced › Measurement units: the Line Numbers "From text" distance and the Hyphenation zone were still fixed in inches (#755) |
+| 2026-10-11 | trivial | Track Changes Options › Show revisions in balloons works: tracked deletions in the body leave the text for "Deleted: …" balloons in the markup area, joined to where they were; inline again where no balloons show (Comments pane, Read Mode, side by side, Web Layout), and always inline in headers, footers, notes and text boxes |
+| 2026-10-11 | trivial | Mini toolbar in two rows like Word's (font, size, grow, shrink; B I U S, highlight, font colour, four alignments) with every button inside the bar; font and size lists drop from the box's left edge; dropdown arrows a readable size; font list entries take the theme's text colour in dark mode (#535) |
+| 2026-10-11 | trivial | Find and Replace: Special ▾ menu (^p, ^t, ^?, ^#, ^$, ^w, ^&, ^c … ; a shorter wildcard list), Use wildcards (`?` `*` `[a-z]` `[!x]` `{n,m}` `@` `<` `>` `( )`, `\1` in Replace with), Match prefix/suffix, Ignore punctuation and white space; `^p` matches and splits paragraphs, Replace All is one undo step (#543) |
+| 2026-10-11 | trivial | Update Style to Match Selection takes how the selection looks (its paragraph and character styles as well as direct formatting) and applies the style to it; Home › Styles gallery tiles get a right-click menu with Update to Match Selection and Modify… (#555) |
+| 2026-10-11 | trivial | Outlining tab in Outline view (level box, promote/demote, move, expand/collapse, Show Level, Show Text Formatting, Show First Line Only, Close); outline symbols select a heading with its content on click and expand/collapse on double-click; Alt+Shift+Plus/Minus, Alt+Shift+1–9, Alt+Shift+A (#493) |
+| 2026-10-11 | trivial | File › Options as panes (General, Display, Proofing, Save, Language, Accessibility, Advanced, Agents), every setting wired; `file.options` headless (#485) |
+| 2026-10-11 | trivial | Right-click on a picture, shape or text box selects it and offers Wrap Text: the seven wrapping styles (current one checked), Move with Text and Fix Position on Page (`arrange.moveWithText`) (#513) |
+| 2026-10-11 | trivial | Paragraph dialog: Mirror indents (Inside/Outside labels), Don't add space between paragraphs of the same style, Formatting exceptions (Suppress line numbers, Don't hyphenate) (#512) |
+| 2026-10-11 | trivial | The caret glides to its new place for keys and typing and its blink fades, as measured from Word for Windows; File › Options › Advanced › Animation turns it off, kept between runs; `ui.caretAnimation` for agents |
+| 2026-10-11 | trivial | Screen readers: the document canvas exposes paragraphs, headings, lists, tables, links, pictures and the caret through AccessKit (#488); 25% → 50% |
+| 2026-10-11 | trivial | More Colors… in every colour drop-down and a Colors dialog (Standard and Custom tabs, RGB/HSL numbers, hex box) with Recent Colors (#606) |
+| 2026-10-11 | trivial | Selection by units: double-click and drag extends by whole words, triple-click and drag by paragraphs, Ctrl/⌘+click and drag by sentences; `select.dragUnit` (#549) |
+| 2026-10-11 | trivial | Compare / Combine Documents (original and revised document, label changes with, comparison settings, word or character level, show changes in) and AutoCorrect Options (replacement list, capitalization, exceptions, AutoFormat As You Type, Math AutoCorrect) dialogs; Restrict Editing pane (formatting and editing restrictions, exceptions for everyone, password); modal dialog rows merged into one (#412) |
+| 2026-10-11 | trivial | Line Numbers, Hyphenation (with Manual Hyphenation), Language, Envelopes and Labels dialogs (#407); the three duplicated modal-dialog rows merged into one |
+| 2026-10-11 | trivial | Accessibility pane (errors/warnings/tips, jump-to, fixes) and Alt Text pane, opened from Picture/Shape Format › Accessibility and right-click › View Alt Text… (#386) |
+| 2026-10-11 | trivial | References dialogs: Caption (New/Delete Label, Numbering with chapter numbers), Index and Mark Index Entry (Mark All), Custom Table of Contents (Options, TOC styles via Modify Style), Source Manager and Create/Edit Source; modal dialog count 34 (#402) |
+| 2026-10-11 | trivial | Dark theme: Share, the avatar initials, the AutoSave knob and keytips use dark `on_accent` text on the light accent (6.2:1, 8.4:1 on hover; white was 2.9:1) (#655) |
+| 2026-10-11 | trivial | Text field and combo outlines reach 3:1 against their fill and surroundings in both themes (light #8A8A8A, dark #7A7A7A); a test pins the ratios (#657) |
+| 2026-10-11 | trivial | Font dialog: Asian text font and Latin text font boxes, each with its own list and type-to-find, shown for a Chinese/Japanese interface or East Asian text in the selection; OK sets only the fonts changed; `format.font {"eastAsia"}` (#505) |
+| 2026-10-11 | trivial | References › Table of Authorities: Insert Table of Authorities is labelled and joined by Update Table (`references.updateAuthorities`), as in the Index group (#661) |
 | 2026-10-11 | trivial | Customize Ribbon (custom tabs and groups, hidden and reordered tabs) and a customizable Quick Access Toolbar with a working … menu (#379, #376) |
 | 2026-10-11 | trivial | Customize Keyboard dialog (Tools › Customize Keyboard, File › Options › Keyboard shortcuts): custom keys override built-ins and persist (#368) |
 | 2026-10-11 | minor | Keyboard shortcuts 101 → 125 commands (#330): Reset Paragraph/Character Formatting, symbols, DATE/TIME/PAGE fields, view switches, Word Count, mail merge, F4 Repeat now reachable |
 | 2026-10-11 | trivial | Collapsed duplicate rows left by parallel merges |
 | 2026-10-11 | trivial | Dialogs keep their top edge in place when switching tabs (Paragraph, Font, Borders and Shading…): only the bottom edge moves (#507) |
 | 2026-10-11 | trivial | Interface size setting in File › Options › General (80–200 %), kept between runs and applied on top of the system's display scale; `ui.interfaceSize` for agents (#475) |
+| 2026-10-11 | trivial | Font list ends with Add Font… (TTF, OTF, TTC, WOFF, WOFF2; also by dropping the file); added fonts are listed at once and kept between runs (#582) |
 | 2026-10-11 | trivial | Font box (ribbon and mini toolbar): typing lists the matching fonts (prefix first, then any part of the name); Up/Down, Enter or a click picks one, Escape cancels (#359) |
+| 2026-10-11 | trivial | Templates and Add-ins (template path, Attach…, automatically update document styles) and Organizer (copy styles from another file, delete, rename) dialogs (#377); styles update from the template only when the user asks (OK with the box ticked, or Update Styles), never on open; the three Modal dialogs rows merged into one |
 | 2026-10-11 | trivial | Field codes (#339): View › Field Codes (Alt+F9), Toggle Field Codes (Shift+F9), a field-code popup (double-click, right-click › Edit Field…; Ctrl+F9 opens the Field dialog), unlink/lock/unlock and next/previous field keys; field items in the context menu |
 | 2026-10-10 | trivial | Tabs dialog (Paragraph › Tabs…, double-click a ruler tab) and Borders and Shading with Borders, Page Border and Shading tabs (#320) |
 | 2026-10-10 | trivial | Columns (presets, unequal widths, line between, apply to), Symbol (font coverage grid by Unicode subset, recently used, character code, Special Characters) and Field (categories, options, field codes) dialogs (#321) |
@@ -59,3 +92,4 @@ own (`AGENTS.md`: no Microsoft iconography, ever).
 | 2026-10-10 | minor | Merged main: Style Inspector, Column Selection, zoom buttons, inertial scrolling, File Info landed |
 | 2026-10-10 | major | First version: ribbon, dialog, shortcut and interaction inventory |
 | 2026-10-10 | trivial | Draw tab tools and Review › Hide Ink (#307) |
+| 2026-10-11 | trivial | Draw: Lasso, Add Pen gallery, Ink to Shape and Ink Replay (#395) |
diff --git a/docs/zotero.md b/docs/zotero.md
index 4041691d37..f05b62c6e2 100644
--- a/docs/zotero.md
+++ b/docs/zotero.md
@@ -21,7 +21,9 @@ Citations (each runs one of the commands below).
 
 They run in the app (and through the control channel and MCP bridged to the app). A command
 returns at once with `{"started": …}`; Zotero then works in its own window and WordCraft answers
-it in the background. All changes from one command are one undo step.
+it in the background. All changes from one command are one undo step. If New or Open replaces
+the document while a command is running, Zotero's remaining calls for it get an error and the
+new document is left as it is.
 
 From a terminal, against a file: