Fix #293: the dock's double arrow collapses its panels to icons

The » at the top of the right dock was only painted. Its header strip is
now a click target (hover highlight, "Collapse to Icons" tooltip) that
runs the new window.collapseDock UI command: the Properties | Layers |
Libraries group hides and its three panels become icons at the top of
the icon column, under a « strip ("Expand Panels") that expands them
again. While collapsed, those icons and window.panel pop the panel out
next to the column like the other icon panels (dock-width flyout, Layers
and Properties given a height that keeps them on screen); expanding with
one popped out shows its tab.

The flyout now follows the icon column's real left edge (recorded each
frame) instead of assuming a 300-point dock, so it also tracks a resized
or collapsed dock. The collapsed state is kept with the UI preferences
and in user workspaces; the built-in workspaces expand the dock.

Co-Authored-By: Claude Opus 5.5 <[email protected]>

.github/workflows/freebsd.yml

@@ -1,5 +1,6 @@
 # Builds and tests the workspace on FreeBSD, inside a FreeBSD VM on a Linux runner
 # (GitHub has no FreeBSD runners). GPU tests skip themselves when the VM has no adapter.
+# The `package` job checks packaging/freebsd/package.sh (the release job runs it for real).
 name: FreeBSD
 
 on:
@@ -11,6 +12,8 @@ on:
       - Cargo.lock
       - "**/Cargo.toml"
       - .github/workflows/freebsd.yml
+      - packaging/freebsd/**
+      - packaging/env.sh
   workflow_dispatch:
 
 concurrency:
@@ -27,6 +30,13 @@ jobs:
     timeout-minutes: 300
     steps:
       - uses: actions/checkout@v4
+      # The optional craft-fonts build input (Japanese fonts), so the tests that need it run here
+      # rather than skip. Pinned; bump deliberately (craftrules standards/fonts.md).
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          repository: storytold/craft-fonts
+          ref: abb83316d96aa59c1cf64784289e378fe9fa5695
+          path: craft-fonts
       - name: Build and test in a FreeBSD VM
         uses: vmactions/freebsd-vm@c46abacb49f09938ca4e1702d15d836285d694cc # v1
         with:
@@ -44,5 +54,51 @@ jobs:
             # The checkout is synced in under another owner; let tests that call git read it.
             git config --global --add safe.directory "*"
             rustc --version
+            # The checkout above is synced into the VM with the workspace.
+            export CRAFT_FONTS_DIR="$PWD/craft-fonts" CRAFT_FONTS_REQUIRED=1
             CARGO_PROFILE_DEV_DEBUG=0 cargo build --workspace --all-targets --locked
             CARGO_PROFILE_DEV_DEBUG=0 cargo test --workspace --locked
+
+  package:
+    name: FreeBSD 14 (package)
+    # The release build takes a while: only for PRs that touch FreeBSD packaging (or dependencies)
+    # and on demand, not on every push to main.
+    if: github.event_name != 'push'
+    runs-on: ubuntu-latest
+    timeout-minutes: 150
+    steps:
+      - uses: actions/checkout@v4
+      # Japanese UI/document fonts, embedded by crates/text/build.rs (CRAFT_FONTS_DIR in the VM).
+      # Bump the commit deliberately; see craftrules standards/fonts.md.
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          repository: storytold/craft-fonts
+          ref: abb83316d96aa59c1cf64784289e378fe9fa5695
+          path: craft-fonts
+      - name: Package in a FreeBSD VM
+        uses: vmactions/freebsd-vm@c46abacb49f09938ca4e1702d15d836285d694cc
+        with:
+          release: "14.3"
+          usesh: true
+          mem: 12288
+          prepare: |
+            pkg install -y bash curl git pkgconf cmake python3 libxkbcommon wayland libX11 libXcursor libXrandr libXi libxcb mesa-libs vulkan-loader gtk3 fontconfig freetype2 alsa-lib
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain stable
+          run: |
+            . "$HOME/.cargo/env"
+            git config --global --add safe.directory "$PWD"
+            # Build outside the checkout so only dist/ is copied back out of the VM.
+            # The craft-fonts checkout is synced into the VM with the workspace.
+            export CRAFT_FONTS_DIR="$PWD/craft-fonts" CRAFT_FONTS_REQUIRED=1
+            export CARGO_TARGET_DIR=/var/tmp/vectorcraft-target CARGO_BUILD_JOBS=4
+            bash packaging/freebsd/package.sh
+            # Every part the package must have, the craft-fonts licences included.
+            tar -tzf dist/release/vectorcraft-*-freebsd-x86_64.tar.gz >/var/tmp/contents.txt
+            for want in '/bin/vectorcraft$' '/bin/vectorcraft-cli$' '/share/applications/.*\.desktop$' '/share/icons/hicolor/' '/share/doc/vectorcraft/NOTICE$' '/share/doc/vectorcraft/OFL-.*\.txt$'; do
+              grep -Eq "$want" /var/tmp/contents.txt || { echo "missing from the package: $want"; exit 1; }
+            done
+      - uses: actions/upload-artifact@v4
+        with:
+          name: freebsd-package
+          path: dist/release/*
+          if-no-files-found: error

.github/workflows/packaging-lint.yml

@@ -47,6 +47,10 @@ jobs:
       - name: XML, desktop entry, AppStream, Flatpak manifest
         run: |
           xmllint --noout packaging/windows/vectorcraft.wxs packaging/macos/*.plist* packaging/linux/*.xml*
+          # Windows Installer needs Icon ids ending in .ico or .exe, or shortcuts show a blank icon.
+          if grep -oE '<Icon Id="[^"]*"' packaging/windows/vectorcraft.wxs | grep -vE '\.(ico|exe)"$'; then
+            echo "::error::Icon Id must end in .ico or .exe"; exit 1
+          fi
           desktop-file-validate packaging/linux/ai.storyteller.vectorcraft.desktop
           sed -e 's/@VERSION@/0.0.0/' -e 's/@DATE@/2026-01-01/' packaging/linux/ai.storyteller.vectorcraft.metainfo.xml.in >"$RUNNER_TEMP/ai.storyteller.vectorcraft.metainfo.xml"
           appstreamcli validate --no-net --explain "$RUNNER_TEMP/ai.storyteller.vectorcraft.metainfo.xml"

.github/workflows/release.yml

@@ -70,6 +70,13 @@ jobs:
       VECTORCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
     steps:
       - uses: actions/checkout@v4
+      # Japanese UI/document fonts, embedded by crates/text/build.rs (CRAFT_FONTS_DIR on the build
+      # step). Bump the commit deliberately; see craftrules standards/fonts.md.
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          repository: storytold/craft-fonts
+          ref: abb83316d96aa59c1cf64784289e378fe9fa5695
+          path: craft-fonts
       - uses: dtolnay/rust-toolchain@stable
         with:
           targets: aarch64-apple-darwin, x86_64-apple-darwin
@@ -90,6 +97,8 @@ jobs:
           APPLE_ID: ${{ secrets.APPLE_ID }}
           APPLE_PASSWORD: ${{ secrets.APPLE_PASSWORD }}
           APPLE_TEAM_ID: ${{ secrets.APPLE_TEAM_ID }}
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
         run: packaging/macos/package.sh --arch universal
       - uses: actions/upload-artifact@v4
         with:
@@ -112,11 +121,21 @@ jobs:
         include:
           - { arch: x64, target: x86_64-pc-windows-msvc }
           - { arch: x86, target: i686-pc-windows-msvc }
+          # Windows on ARM: cross-compiled on the x64 runner, so signing and WiX run as above.
+          # .github/workflows/windows-arm64.yml installs and runs it on ARM64 hardware.
+          - { arch: arm64, target: aarch64-pc-windows-msvc }
     env:
       VECTORCRAFT_VERSION: ${{ needs.version.outputs.version }}
       VECTORCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
     steps:
       - uses: actions/checkout@v4
+      # Japanese UI/document fonts, embedded by crates/text/build.rs (CRAFT_FONTS_DIR on the build
+      # step). Bump the commit deliberately; see craftrules standards/fonts.md.
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          repository: storytold/craft-fonts
+          ref: abb83316d96aa59c1cf64784289e378fe9fa5695
+          path: craft-fonts
       - uses: dtolnay/rust-toolchain@stable
         with:
           targets: ${{ matrix.target }}
@@ -141,6 +160,8 @@ jobs:
           AZURE_SIGNING_ENDPOINT: ${{ secrets.AZURE_SIGNING_ENDPOINT }}
           AZURE_SIGNING_ACCOUNT: ${{ secrets.AZURE_SIGNING_ACCOUNT }}
           AZURE_CERT_PROFILE: ${{ secrets.AZURE_CERT_PROFILE }}
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
         run: ./packaging/windows/package.ps1 -Arch ${{ matrix.arch }}
       - uses: actions/upload-artifact@v4
         with:
@@ -167,6 +188,13 @@ jobs:
       NFPM_VERSION: 2.47.0
     steps:
       - uses: actions/checkout@v4
+      # Japanese UI/document fonts, embedded by crates/text/build.rs (CRAFT_FONTS_DIR on the build
+      # step). Bump the commit deliberately; see craftrules standards/fonts.md.
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          repository: storytold/craft-fonts
+          ref: abb83316d96aa59c1cf64784289e378fe9fa5695
+          path: craft-fonts
       - name: Install build and packaging tools
         run: |
           sudo apt-get update
@@ -184,6 +212,9 @@ jobs:
         if: inputs.version != ''
         run: cargo xtask version set "$VECTORCRAFT_VERSION"
       - name: Build and package (AppImage, deb, rpm, tar.gz)
+        env:
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
         run: packaging/linux/package.sh
       - name: Check the packages
         run: |
@@ -201,6 +232,56 @@ jobs:
           path: dist/release/*
           if-no-files-found: error
 
+  freebsd:
+    name: FreeBSD x86_64
+    needs: version
+    # GitHub has no FreeBSD runners: build in a FreeBSD 14.3 VM (same image as freebsd.yml).
+    runs-on: ubuntu-latest
+    timeout-minutes: 150
+    environment: release
+    env:
+      VECTORCRAFT_VERSION: ${{ needs.version.outputs.version }}
+      VECTORCRAFT_BUILD_DATE: ${{ needs.version.outputs.date }}
+    steps:
+      - uses: actions/checkout@v4
+      # Japanese UI/document fonts, embedded by crates/text/build.rs (CRAFT_FONTS_DIR in the VM).
+      # Bump the commit deliberately; see craftrules standards/fonts.md.
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          repository: storytold/craft-fonts
+          ref: abb83316d96aa59c1cf64784289e378fe9fa5695
+          path: craft-fonts
+      - uses: dtolnay/rust-toolchain@stable
+        if: inputs.version != ''
+      - name: Apply version override
+        if: inputs.version != ''
+        run: cargo xtask version set "$VECTORCRAFT_VERSION"
+      - name: Build and package in a FreeBSD VM
+        # v1.5.9, pinned by commit.
+        uses: vmactions/freebsd-vm@c46abacb49f09938ca4e1702d15d836285d694cc
+        with:
+          release: "14.3"
+          usesh: true
+          mem: 12288
+          # Passed through by name; never templated into the script.
+          envs: "VECTORCRAFT_VERSION VECTORCRAFT_BUILD_DATE VECTORCRAFT_BUILD_SHA"
+          prepare: |
+            pkg install -y bash curl git pkgconf cmake python3 libxkbcommon wayland libX11 libXcursor libXrandr libXi libxcb mesa-libs vulkan-loader gtk3 fontconfig freetype2 alsa-lib
+            curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --profile minimal --default-toolchain stable
+          run: |
+            . "$HOME/.cargo/env"
+            git config --global --add safe.directory "$PWD"
+            # Build outside the checkout so only dist/ is copied back out of the VM.
+            # The craft-fonts checkout is synced into the VM with the workspace.
+            export CRAFT_FONTS_DIR="$PWD/craft-fonts" CRAFT_FONTS_REQUIRED=1
+            export CARGO_TARGET_DIR=/var/tmp/vectorcraft-target CARGO_BUILD_JOBS=4
+            bash packaging/freebsd/package.sh
+      - uses: actions/upload-artifact@v4
+        with:
+          name: release-freebsd
+          path: dist/release/*
+          if-no-files-found: error
+
   web:
     name: Web (wasm)
     needs: version
@@ -212,6 +293,13 @@ jobs:
       TRUNK_VERSION: 0.21.14
     steps:
       - uses: actions/checkout@v4
+      # Japanese UI/document fonts, embedded by crates/text/build.rs (CRAFT_FONTS_DIR on the build
+      # step). Bump the commit deliberately; see craftrules standards/fonts.md.
+      - uses: actions/checkout@11bd71901bbe5b1630ceea73d27597364c9af683 # v4.2.2
+        with:
+          repository: storytold/craft-fonts
+          ref: abb83316d96aa59c1cf64784289e378fe9fa5695
+          path: craft-fonts
       - uses: dtolnay/rust-toolchain@stable
         with:
           targets: wasm32-unknown-unknown
@@ -227,6 +315,9 @@ jobs:
         if: inputs.version != ''
         run: cargo xtask version set "$VECTORCRAFT_VERSION"
       - name: Build and zip
+        env:
+          CRAFT_FONTS_DIR: ${{ github.workspace }}/craft-fonts
+          CRAFT_FONTS_REQUIRED: "1"
         run: packaging/web/package.sh
       - uses: actions/upload-artifact@v4
         with:
@@ -236,7 +327,7 @@ jobs:
 
   release:
     name: Draft GitHub Release
-    needs: [version, macos, windows, linux, web]
+    needs: [version, macos, windows, linux, freebsd, web]
     runs-on: ubuntu-latest
     environment: release
     permissions:

.github/workflows/windows-arm64.yml

@@ -0,0 +1,95 @@
+# Windows on ARM: package the ARM64 release the way release.yml does (cross-compiled on an x64
+# runner, unsigned here), then install that MSI on a Windows 11 ARM64 runner, check the installed
+# binaries are ARM64, run the CLI natively, and uninstall. (A native ARM64 `cargo test` job is left
+# out for now: PrintCraft saw an intermittent access violation in egui UI tests there.)
+name: Windows ARM64
+
+on:
+  push:
+    branches: [main]
+  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:
+  group: windows-arm64-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: 0
+
+jobs:
+  package:
+    name: package (cross-compiled on x64)
+    runs-on: windows-latest
+    timeout-minutes: 90
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@89b12181fb390509a0842a86cc55eeb8eb928c1d # stable
+        with:
+          targets: aarch64-pc-windows-msvc
+      - uses: Swatinem/rust-cache@6323deb102c322ba6fcbdcafc7e3dddab59af2b6 # v2
+        with:
+          key: windows-arm64-package
+      - name: Install WiX
+        shell: pwsh
+        run: dotnet tool install --global wix --version 5.0.2
+      - name: Build and package (unsigned)
+        shell: pwsh
+        env:
+          DIST: ${{ github.workspace }}\dist\arm64
+        run: ./packaging/windows/package.ps1 -Arch arm64
+      - uses: actions/upload-artifact@v4
+        with:
+          name: vectorcraft-windows-arm64
+          path: dist/arm64/*
+          if-no-files-found: error
+          retention-days: 7
+
+  install:
+    name: install and run on ARM64
+    needs: package
+    runs-on: windows-11-arm
+    timeout-minutes: 30
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: vectorcraft-windows-arm64
+          path: dist
+      - name: Install the MSI, check it, run it, uninstall it
+        shell: pwsh
+        run: |
+          $ErrorActionPreference = 'Stop'
+          $msi = (Get-ChildItem dist/*.msi | Select-Object -First 1).FullName
+          $p = Start-Process msiexec.exe -ArgumentList '/i', "`"$msi`"", '/qn', '/l*v', 'install.log' -Wait -PassThru
+          if ($p.ExitCode -ne 0) { Get-Content install.log -Tail 60; throw "msiexec /i exited $($p.ExitCode)" }
+          $dir = Join-Path $env:ProgramFiles 'VectorCraft'
+          foreach ($exe in 'vectorcraft.exe', 'vectorcraft-cli.exe') {
+            $path = Join-Path $dir $exe
+            if (-not (Test-Path $path)) { throw "$exe not installed in $dir" }
+            $bytes = [System.IO.File]::ReadAllBytes($path)
+            $machine = [BitConverter]::ToUInt16($bytes, [BitConverter]::ToInt32($bytes, 0x3C) + 4)
+            if ($machine -ne 0xAA64) { throw "$exe is for machine 0x$('{0:X}' -f $machine), not ARM64" }
+            Write-Output "ok $path (ARM64)"
+          }
+          # The installed CLI runs natively on ARM64.
+          $cli = Join-Path $dir 'vectorcraft-cli.exe'
+          $out = & $cli --version 2>&1 | Out-String
+          if ($LASTEXITCODE -ne 0) { Write-Output $out; throw "vectorcraft-cli --version exited $LASTEXITCODE" }
+          Write-Output "ok vectorcraft-cli --version: $($out.Trim())"
+          $p = Start-Process msiexec.exe -ArgumentList '/x', "`"$msi`"", '/qn' -Wait -PassThru
+          if ($p.ExitCode -ne 0) { throw "msiexec /x exited $($p.ExitCode)" }
+          if (Test-Path (Join-Path $dir 'vectorcraft.exe')) { throw 'uninstall left vectorcraft.exe behind' }
+          Write-Output 'ok uninstalled'

.gitignore

@@ -5,3 +5,5 @@ plan/
 /corpus
 /log
 .DS_Store
+# A craft-fonts checkout for CRAFT_FONTS_DIR (CI and release workflows check it out here)
+/craft-fonts

AGENTS.md

@@ -22,6 +22,7 @@ Formerly **DrawCraft** (renamed 2026-10-01): old `.drawcraft` files and `"format
     - Creative Commons with redistribution allowed.
   - **Every asset file must have a row in [`ASSETS.md`](ASSETS.md)** (path, author, source URL, licence, notes). Put licence texts next to the assets (e.g. `assets/fonts/OFL-*.txt`) and summarize them in `NOTICE`.
   - `cargo xtask assets` (run by `cargo xtask ci`) fails on any unattributed asset.
+  - **Fonts live in [storytold/craft-fonts](https://github.com/storytold/craft-fonts), never in this repo** (rules: craftrules [`standards/fonts.md`](https://github.com/storytold/craftrules/blob/main/standards/fonts.md)). Never commit a font file here; add new fonts to craft-fonts. The app uses it only through the optional `CRAFT_FONTS_DIR` build option (`CRAFT_FONTS_DIR="$PWD/../craft-fonts" cargo xtask ci`; use an absolute path), read by `crates/text/build.rs` into `vectorcraft_text::CRAFT_FONTS`; never add it to a `Cargo.toml`. Everything must build, test and run with `CRAFT_FONTS` empty, and tests of its glyphs skip when it is. Details: `docs/development.md` › Fonts.
   - Code and original assets are MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`, `NOTICE`). The ArtCraft logos in `docs/brand/` are trademarks, not open source, under `docs/brand/LICENSE-brand.txt`: never modify them or use them outside VectorCraft.
   - Prefer art generated in code for defaults (swatches, brushes, symbols, patterns, cursors). If the provenance of an asset is unclear, don't add it.
   - Reference screenshots of Illustrator stay local under the gitignored `plan/` and are never committed, published or used as assets.

ASSETS.md

@@ -6,6 +6,10 @@ Every non-code asset in this repository (icons, images, fonts, example art, colo
 
 Generated-in-code art is original and has no file to list. This covers the default swatches, brushes, symbols, patterns, graphic styles, image-trace presets and the vector tool cursors (`crates/ui-egui/src/cursors.rs`).
 
+**Font files are never committed here.** Fonts shared by the Crafting Apps live in [storytold/craft-fonts](https://github.com/storytold/craft-fonts) (rules: craftrules [`standards/fonts.md`](https://github.com/storytold/craftrules/blob/main/standards/fonts.md)). The small Latin UI/document fonts below predate that rule and stay.
+
+**Optional build input: craft-fonts.** Builds made with `CRAFT_FONTS_DIR=<craft-fonts checkout>` (all official releases) embed the Japanese fonts listed in its [`ATTRIBUTION.md`](https://github.com/storytold/craft-fonts/blob/main/ATTRIBUTION.md): BIZ UDPGothic Regular and Bold, Shippori Mincho Regular and BIZ UDMincho Regular (web builds: BIZ UDPGothic Regular only), all under the SIL Open Font License 1.1. They are not files in this repository; release packages carry each one's `OFL-<family>.txt`. Builds without `CRAFT_FONTS_DIR` embed none of them.
+
 | Asset | Author | Source | Licence | Notes |
 |---|---|---|---|---|
 | `docs/brand/artcraft-logo-white.png` | ArtCraft team (project owner) | https://getartcraft.com/ | ArtCraft trademark, see docs/brand/LICENSE-brand.txt (not open source) | Used in README only; not shipped in the app |

CLAUDE.md

@@ -22,6 +22,7 @@ Formerly **DrawCraft** (renamed 2026-10-01): old `.drawcraft` files and `"format
     - Creative Commons with redistribution allowed.
   - **Every asset file must have a row in [`ASSETS.md`](ASSETS.md)** (path, author, source URL, licence, notes). Put licence texts next to the assets (e.g. `assets/fonts/OFL-*.txt`) and summarize them in `NOTICE`.
   - `cargo xtask assets` (run by `cargo xtask ci`) fails on any unattributed asset.
+  - **Fonts live in [storytold/craft-fonts](https://github.com/storytold/craft-fonts), never in this repo** (rules: craftrules [`standards/fonts.md`](https://github.com/storytold/craftrules/blob/main/standards/fonts.md)). Never commit a font file here; add new fonts to craft-fonts. The app uses it only through the optional `CRAFT_FONTS_DIR` build option (`CRAFT_FONTS_DIR="$PWD/../craft-fonts" cargo xtask ci`; use an absolute path), read by `crates/text/build.rs` into `vectorcraft_text::CRAFT_FONTS`; never add it to a `Cargo.toml`. Everything must build, test and run with `CRAFT_FONTS` empty, and tests of its glyphs skip when it is. Details: `docs/development.md` › Fonts.
   - Code and original assets are MIT OR Apache-2.0 (`LICENSE-MIT`, `LICENSE-APACHE`, `NOTICE`). The ArtCraft logos in `docs/brand/` are trademarks, not open source, under `docs/brand/LICENSE-brand.txt`: never modify them or use them outside VectorCraft.
   - Prefer art generated in code for defaults (swatches, brushes, symbols, patterns, cursors). If the provenance of an asset is unclear, don't add it.
   - Reference screenshots of Illustrator stay local under the gitignored `plan/` and are never committed, published or used as assets.

Cargo.lock

@@ -4211,7 +4211,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "arboard",
  "clipboard-win",
@@ -4220,6 +4220,8 @@ dependencies = [
  "image",
  "log",
  "muda",
+ "objc2 0.6.4",
+ "objc2-app-kit 0.3.2",
  "rfd",
  "serde_json",
  "vectorcraft-engine",
@@ -4231,7 +4233,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-brush"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "kurbo 0.13.1",
  "serde",
@@ -4243,7 +4245,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-cad"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "image",
  "kurbo 0.13.1",
@@ -4259,7 +4261,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-cli"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "serde_json",
  "vectorcraft-color",
@@ -4275,7 +4277,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-color"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "kurbo 0.13.1",
  "moxcms",
@@ -4287,7 +4289,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-doc"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "image",
  "kurbo 0.13.1",
@@ -4301,7 +4303,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-effects"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "kurbo 0.13.1",
  "serde_json",
@@ -4315,7 +4317,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-engine"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "flate2",
  "image",
@@ -4347,7 +4349,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-eps"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "flate2",
  "image",
@@ -4364,7 +4366,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-format"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "flate2",
  "proptest",
@@ -4378,7 +4380,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-geom"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "kurbo 0.13.1",
  "proptest",
@@ -4390,7 +4392,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-mcp"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "image",
  "log",
@@ -4409,7 +4411,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-metafile"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "image",
  "kurbo 0.13.1",
@@ -4423,7 +4425,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-pathops"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "kurbo 0.13.1",
  "linesweeper",
@@ -4435,7 +4437,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-pdf"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "aes",
  "flate2",
@@ -4462,7 +4464,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-plugins"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "serde",
  "serde_json",
@@ -4476,7 +4478,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-render"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "flate2",
  "gif",
@@ -4501,7 +4503,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-svg"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "flate2",
  "image",
@@ -4525,7 +4527,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-testkit"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "image",
  "kurbo 0.13.1",
@@ -4542,7 +4544,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-text"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "harfrust 0.13.3",
  "kurbo 0.13.1",
@@ -4551,11 +4553,12 @@ dependencies = [
  "subsetter",
  "vectorcraft-doc",
  "vectorcraft-geom",
+ "write-fonts",
 ]
 
 [[package]]
 name = "vectorcraft-tools"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "image",
  "kurbo 0.13.1",
@@ -4570,7 +4573,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-trace"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "image",
  "kurbo 0.13.1",
@@ -4583,7 +4586,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-ui-egui"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "egui",
  "egui_extras",
@@ -4611,7 +4614,7 @@ dependencies = [
 
 [[package]]
 name = "vectorcraft-web"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "eframe",
  "egui",
@@ -5685,7 +5688,7 @@ checksum = "9440ea3e5aeabb0ac63af70daf835274065238cdd0cec83418f417eae38bacee"
 
 [[package]]
 name = "xtask"
-version = "0.3.0"
+version = "0.4.0"
 dependencies = [
  "serde_json",
 ]

Cargo.toml

@@ -4,7 +4,7 @@ members = ["crates/*", "apps/*", "xtask"]
 default-members = ["crates/*", "apps/vectorcraft", "apps/vectorcraft-cli", "xtask"]
 
 [workspace.package]
-version = "0.3.0"
+version = "0.4.0"
 edition = "2024"
 license = "MIT OR Apache-2.0"
 rust-version = "1.95"

NOTICE

@@ -29,3 +29,8 @@ based in part on the work of the Independent JPEG Group.
 
 WebAssembly plug-ins run in the wasmi interpreter (MIT OR Apache-2.0); its wasmparser dependency is
 under the Apache License 2.0 with the LLVM exception.
+
+Builds made with craft-fonts (the CRAFT_FONTS_DIR build option; all official releases) embed the
+fonts listed in https://github.com/storytold/craft-fonts/blob/main/ATTRIBUTION.md (today BIZ
+UDPGothic, Shippori Mincho and BIZ UDMincho; web builds BIZ UDPGothic Regular only) under the SIL
+Open Font License 1.1. Their license texts ship with the release packages as OFL-<family>.txt.

README.md

@@ -16,13 +16,13 @@
 
 <p align="center">
   A fast, open-source, clean-room take on the Adobe Illustrator workflow. It runs natively on
-  macOS, Windows and Linux, and in the browser via WebAssembly. Built by the ArtCraft team.
+  macOS, Windows, Linux and FreeBSD, and in the browser via WebAssembly. Built by the ArtCraft team.
 </p>
 
 <p align="center">
   <img alt="Status: in active development" src="https://img.shields.io/badge/status-in%20active%20development-e8573f">
   <img alt="Written in pure Rust" src="https://img.shields.io/badge/pure-Rust-b83a24?logo=rust&logoColor=white">
-  <img alt="Runs on macOS, Windows, Linux and the web" src="https://img.shields.io/badge/runs%20on-macOS%20%C2%B7%20Windows%20%C2%B7%20Linux%20%C2%B7%20Web-555555">
+  <img alt="Runs on macOS, Windows, Linux, FreeBSD and the web" src="https://img.shields.io/badge/runs%20on-macOS%20%C2%B7%20Windows%20%C2%B7%20Linux%20%C2%B7%20FreeBSD%20%C2%B7%20Web-555555">
   <img alt="MCP server for agents" src="https://img.shields.io/badge/agents-MCP%20server-555555">
   <img alt="License: MIT OR Apache-2.0" src="https://img.shields.io/badge/license-MIT%20OR%20Apache--2.0-555555">
 </p>
@@ -154,6 +154,14 @@ cd apps/vectorcraft-web && trunk build --release            # web build → dist
 cargo xtask ci                                            # fmt, clippy, tests, layering, wasm, vendor names
 ```
 
+Japanese fonts come from [storytold/craft-fonts](https://github.com/storytold/craft-fonts), an optional
+build input (releases always use it): `CRAFT_FONTS_DIR="$PWD/../craft-fonts" cargo run --release -p vectorcraft` (an absolute path).
+Without it, Japanese text uses the installed system fonts. See [`docs/development.md`](docs/development.md#fonts-craft-fonts-optional-build-input).
+
+On laptops with two graphics processors, VectorCraft uses the power-saving (integrated) one by default.
+To use the discrete one, choose **Preferences › Performance › Graphics Processor › High Performance**
+and restart, or start the app with `WGPU_POWER_PREF=high` (see [`docs/development.md`](docs/development.md#desktop-graphics-processor)).
+
 ### Use it from Claude Code and other agents
 
 Register the MCP server with Claude Code:
@@ -178,7 +186,7 @@ self-assessed, so the [honest assessment](ROADMAP.md#honest-assessment-2026-10-0
 **What's missing:**
 - 3D and Materials;
 - the Photoshop-style raster effects (Effect Gallery);
-- vertical and CJK type;
+- CJK composition for vertical type (vertical type itself has initial support, with a Japanese interface);
 - Variables and scripting;
 - an interaction-fidelity pass covering every tool's modifiers and small behaviours;
 - packaging for Windows and Linux.
@@ -193,7 +201,8 @@ the UI can be swapped without touching the engine.
 
 Agent and contributor rules (clean-room, the asset policy, no panics in shipped code, quality gates) are in
 [`AGENTS.md`](AGENTS.md); [`docs/development.md`](docs/development.md#robustness-vectorcraft-never-crashes)
-explains how VectorCraft avoids crashing. Every bundled asset is listed with its licence in [`ASSETS.md`](ASSETS.md).
+explains how VectorCraft avoids crashing, and [`docs/releasing.md`](docs/releasing.md) how releases are built,
+signed and published. Every bundled asset is listed with its licence in [`ASSETS.md`](ASSETS.md).
 
 ## The Crafting Apps
 
@@ -241,7 +250,9 @@ VectorCraft is dual-licensed under [MIT](LICENSE-MIT) or [Apache-2.0](LICENSE-AP
 Copyright (c) 2026 ArtCraft Team and the VectorCraft contributors. Required notices are in [NOTICE](NOTICE).
 
 Bundled fonts, icons, images and other assets keep their own open licenses; each one is listed
-with its author, source and license in [ASSETS.md](ASSETS.md).
+with its author, source and license in [ASSETS.md](ASSETS.md). Release builds also embed the
+Japanese fonts of [craft-fonts](https://github.com/storytold/craft-fonts/blob/main/ATTRIBUTION.md)
+(SIL Open Font License 1.1).
 
 The app icon (an engraved dragon on VectorCraft red, `#e8573f`) is the owner's original artwork; its
 palette and files are in [`assets/app-icon/`](assets/app-icon/README.md).

ROADMAP.md

@@ -4,7 +4,7 @@ VectorCraft is a clean-room, open-source, pure-Rust reimplementation of the Adob
 
 This file tracks **how far we are and what's left**. Time estimates are wall-clock hours of continuous Claude Opus 5.5 agent work (including builds and the CI gate), given both for **one agent** and for **4–6 parallel agents** on disjoint crates. They are counted from the remaining work (see [Parity estimate](#parity-estimate)), calibrated against measured throughput, and updated as work lands.
 
-_Last updated: 2026-10-06 (after M4.14–M4.98, M8.1–M8.20 and M14.4–M14.7; see [Honest assessment](#honest-assessment-2026-10-05))._
+_Last updated: 2026-10-07 (after M4.14–M4.98, M8.1–M8.20, M14.4–M14.7, the MCP prompts, resource templates, completions and logging, and the 2026-10-07 issue fixes; see [Honest assessment](#honest-assessment-2026-10-05))._
 
 ## Where we are
 
@@ -14,8 +14,8 @@ _Last updated: 2026-10-06 (after M4.14–M4.98, M8.1–M8.20 and M14.4–M14.7;
 | Look & feel vs Illustrator 2026 default workspace (measured) | **~75–80%** |
 | Feature surface vs full Illustrator (weighted, see below) | **~75%** on the rubric · **69–75%** honest range (self-graded, see [Honest assessment](#honest-assessment-2026-10-05)) |
 | Parity including interaction fidelity and hardening ("a power user can't tell the difference, but faster") | **~40–55%** |
-| Time to **feature parity** (every menu item, tool, panel, effect and dialog functional) | **~225–345 h** one agent · **~60–100 h** with 4–6 agents |
-| Time to **full parity** (feature parity + interaction-fidelity pass + hardening) | **~330–515 h** one agent · **~85–150 h** with 4–6 agents |
+| Time to **feature parity** (every menu item, tool, panel, effect and dialog functional) | **~210–330 h** one agent · **~55–95 h** with 4–6 agents |
+| Time to **full parity** (feature parity + interaction-fidelity pass + hardening) | **~320–500 h** one agent · **~80–145 h** with 4–6 agents |
 
 ## Honest assessment (2026-10-05)
 
@@ -33,16 +33,16 @@ since 2026-10-01.
 
 | Dimension | Estimate | Evidence and what's missing |
 |---|---|---|
-| **Breadth:** menus, tools and panels exist | ~90% | 18 menu items still stubbed; every tool implemented except Touch Type and vertical type ×3; 51 panel modules |
-| **Depth:** each feature behaves like Illustrator | ~69–75% | Strong: paint, appearance and colour (M3), Pathfinder and booleans, selection, drawing, files (M4). Weak: advanced type (~35%), brushes and symbols (in progress), raster effects (~20%) |
-| **Large missing subsystems** | 0–20% | 3D & Materials (0%), Photoshop-style raster effects and the Effect Gallery (~1 of ~56 filters), SVG Filters, vertical/CJK type, Variables (data merge), scripting |
+| **Breadth:** menus, tools and panels exist | ~90% | 16 menu items still stubbed; every tool implemented except Touch Type; 51 panel modules |
+| **Depth:** each feature behaves like Illustrator | ~69–75% | Strong: paint, appearance and colour (M3), Pathfinder and booleans, selection, drawing, files (M4). Weak: advanced type (~45%), brushes and symbols (in progress), raster effects (~20%) |
+| **Large missing subsystems** | 0–20% | 3D & Materials (0%), Photoshop-style raster effects and the Effect Gallery (~1 of ~56 filters), SVG Filters, CJK composition (vertical type with kinsoku and tate-chu-yoko; ruby, mojikumi and vertical metrics open), Variables (data merge), scripting |
 | **Interaction fidelity:** modifiers, cursors, small behaviours | ~30–40% | The dedicated pass hasn't started, and there has been no side-by-side session with Illustrator yet. A power user notices this first |
 | **Look & feel** | ~75–80% | Measured against Illustrator 2026 screenshots (2026-10-02); the panels added since haven't been re-measured |
 | **File interop** | ~85% | SVG/SVGZ, PDF and PDF-compatible `.ai`, EPS, DXF, EMF/WMF, raster formats, PSD export, Place and Links, Package, Print, clipboard flavours. Native `.ai` private data is out of scope by design; DWG has no open spec |
 | **Bundled content:** brush, symbol, style and swatch libraries | ~30% | Ours are original and generated in code, and far fewer than Illustrator ships; brush and symbol libraries are still missing |
 | **Performance** | unverified | Multithreaded, off-thread rendering and caches are in place. The last budget run (2026-10-01, loaded machine) measured 290 ms for a 50k-path fit against a 16 ms budget. Re-run `vectorcraft-cli perf` on an idle machine |
 | **Robustness** | good, new | ~2,840 tests, property tests, no panics in shipped code (lints, the `guard` safety net, import fuzzing), Data Recovery. Missing: a corpus of real-world files, Windows/Linux/browser QA |
-| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work; Windows/Linux packaging and accessibility are pending |
+| **Platforms and 1.0 polish** | ~60% | The macOS app and the web build work; hybrid-graphics laptops render on the power-saving GPU by default (#306); Windows/Linux packaging and accessibility are pending |
 | **Agent automation** | beyond Illustrator | Every command, gesture and dialog is drivable over MCP, the CLI and the control channel |
 
 ### Where we're lacking (in priority order)
@@ -58,9 +58,10 @@ Ordered by how much each gap blocks someone from switching. Sizes are one-agent
 3. **3D and Materials:** Extrude & Bevel, Revolve, Inflate and Rotate with lighting and materials, using a software
    renderer in its own crate (layering allows it below L6), with output in SVG/PDF as rasters or projected vectors.
    The largest single gap. 50–80 h.
-4. **Advanced type:** vertical type and its tools, CJK composition, Optical Margin Alignment, the
-   composer/hyphenation options, tab leaders, a spell-check dictionary (open licence), Touch Type and Snap to Glyph.
-   41–55 h across type core and advanced.
+4. **Advanced type:** CJK composition for vertical type (ruby, mojikumi, vertical font metrics, manual
+   tate-chu-yoko), Optical Margin Alignment, the composer/hyphenation options, tab leaders, a
+   spell-check dictionary (open licence), Touch Type and Snap to Glyph. Vertical point, area and path type have
+   initial support. 35–48 h across type core and advanced.
 5. **Brushes, symbols and libraries:** brush options depth; original brush, symbol and graphic-style libraries
    generated in code (never Adobe's); dynamic symbols; Start Global Edit. 14–22 h.
 6. **Automation:** Variables (data merge), a scripting surface over the command registry, batch. 8–12 h.
@@ -87,32 +88,42 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 - **Automation:**
   - Actions panel (record/playback, persisted), generic parameter dialogs for every "…" command.
   - JSON-lines control channel with real egui pointer and keyboard injection.
-  - MCP server with 25 tools (drawing, text, effects, Pathfinder, transforms, graphs, text wrap, export, screenshots, any command), attached to the running app or headless.
+  - MCP server with 25 tools (drawing, text, effects, Pathfinder, transforms, graphs, text wrap, export, screenshots, any command), attached to the running app or headless. Tool descriptions and replies agree with the engine: format lists come from its format table, `save_file` says it keeps the document's own format, `inspect_document` reports the paint type's characters show, and selection exports report the encoder's warnings.
+  - MCP protocol: five prompts (`prompts/list` / `prompts/get`: poster, icon set, recolour, trace-and-style, export set), `completion/complete` for prompt arguments and template variables read from the live catalogues (formats, effect ids, command ids, trace presets, swatch and object ids), four resource templates (`vectorcraft://object/{id}`, `//command/{id}`, `//effect/{id}`, `//swatch/{name}`) so an agent reads one thing instead of the whole document, and `logging/setLevel` with `notifications/message`. `docs/mcp.md` has a Protocol section covering the capability table and what is deliberately absent (subscriptions, progress, cancellation, sampling, elicitation, Streamable HTTP — all of which need the transport to interleave reads).
   - Headless CLI (`vectorcraft-cli run`, `convert`, `info`, `bench`, `perf`, `mcp`).
   - Actions panel that records and plays back commands.
 - **UI:** Illustrator 2026 layout restyled to measured values:
   - Medium Dark theme, categorized and Advanced toolbars, 35 pt document tabs, 33 pt panel tabs.
   - Hint bar, contextual task bar, 19 dock panels with ≡ menus.
+  - The dock's double arrow collapses Properties, Layers and Libraries to icons at the top of the icon column, popping out like the other icon panels, and expands them again (`window.collapseDock`, kept with the preferences and in saved workspaces). The icon column's own arrow (expanding the icon panels into a full column) is not done.
+  - Localised UI: menus (in-window and native), panels, dialogs, toolbar and Preferences read from per-language catalogs (`crates/ui-egui/src/i18n`, see `docs/development.md`); Traditional Chinese (Taiwan) ships complete, and Czech and Japanese cover every menu label, with system-locale detection on macOS, Windows and Linux, a VectorCraft ▸ Language menu and a Language preference. Names are never translated (fonts and their styles, layers, artboards, saved presets, user libraries, custom workspaces, recent files, plug-ins).
   - Native macOS menu bar, vector tool cursors, a ⌘K command palette, middle-button panning with any tool.
+  - A canvas context menu: right-click selects the object under the pointer and lists what applies to the selection (Undo/Redo, clipboard, group, isolation, join, masks, compound paths, guides, Transform, Arrange, Select, Export Selection), or the view commands on empty canvas.
   - Save / Don't Save / Cancel before closing or quitting with unsaved documents (tabs, Close, Close All, Quit, window close).
   - Four brightness themes, persistent preferences.
-  - On Windows and Linux the app bar is the window's title bar (its own minimize, maximize and close buttons, drag to move, edges to resize), with the dragon app icon as the brand mark; dialogs and menus size to their content.
+  - On Windows and Linux the app bar is the window's title bar (its own minimize, maximize and close buttons, drag to move, edges to resize), with the dragon app icon as the brand mark; dialogs and menus size to their content. As on a native menu bar, once one menu is open, moving the pointer onto another title opens that one.
 - **Tools:**
   - **Selection:** Selection, Direct/Group Selection, Magic Wand, Lasso.
   - **Drawing:** Pen, Curvature, anchor tools, Pencil, Paintbrush, Blob Brush, Smooth, Path Eraser, Join.
   - **Shapes:** all shape tools (including Flare) and the line, arc, spiral and grid tools.
   - **Cutting:** Eraser, Scissors, Knife, Mirror & Cut, Line Cut and Rectangle Cut (real geometry, compound paths keep their holes).
-  - **Transform:** Rotate, Reflect, Scale, Shear (click or Alt-click snaps the reference point to anchors and centres), Reshape, Free Transform (distort/perspective).
-  - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout.
+  - **Transform:** Rotate, Reflect, Scale, Shear (click or Alt-click snaps the reference point to anchors and centres), Reshape, Free Transform (free and perspective distort and shear, switched by the keys held during a handle drag).
+  - **Live Corners:** drag a live rectangle's corner widgets (Selection or Direct Selection) to round all corners, with a radius readout. Corners stay circular when the rectangle is scaled unevenly or along its own sides when rotated (the radius keeps its size, or scales by the mean scale with Scale Corners on); only a shear distorts them.
   - **Graphs:** Column, Stacked Column, Bar, Stacked Bar, Line, Area, Scatter, Pie and Radar graph tools with Graph Data and Graph Type.
   - **Other:** Eyedropper, Gradient annotator, Artboard, Measure, Type, Hand, Zoom, Rotate View.
-- **Drawing aids:** Smart Guides and snapping, and Draw Normal / Behind / Inside modes.
+  - **Editing type:** double-clicking type with a selection tool switches to the Type tool with the caret where it was clicked.
+  - **Temporary tools:** Cmd with any other tool drags with the selection tool used last (Selection, Direct Selection or Group Selection). Held Space pans and Cmd+Space zooms (Cmd+Alt+Space out) whatever the tool.
+  - **Panel drag and drop:** art dragged off the canvas onto the Symbols panel becomes a symbol, and a symbol dragged onto the canvas places an instance where it is dropped.
+  - **Tool double-clicks:** double-clicking a tool's button opens its options: Hand fits the artboard in the window, Zoom shows 100 %, Rotate, Scale, Reflect and Shear open their Object › Transform dialogs, Gradient, Eyedropper, Blend and the Liquify tools their panels or options.
+- **Drawing aids:** Smart Guides and snapping, guides dragged out of the rulers, and Draw Normal / Behind / Inside modes.
+- **Views:** the status bar's artboard navigator (first, previous, next, last; `view.goToArtboard`) goes to an artboard and fits it, and Fit Artboard in Window and Actual Size show the navigator's artboard.
 - **Geometry and effects:**
   - Pathfinder (10 exact curve booleans), Offset, Outline Stroke, Simplify, Clean Up, Split Into Grid, Divide Objects Below.
-  - Live effects with previewing dialogs: Distort & Transform, Path, Convert to Shape, 15 Warp styles, Round Corners, Scribble, Effect → Pathfinder (all 10 operations, live on groups), Color Adjustments (Brightness/Contrast, Curves, Levels, Hue/Saturation, Shift to Color, Temperature/Tint, on vectors, live type and embedded images), and raster drop shadow, glows and feather. SVG and PDF export keep live effects (geometry baked; SVG raster effects as filters).
-- **Type:** Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity), Character and Paragraph Styles (override-preserving redefine), Area Type Options (rows/columns/inset/first baseline), threaded text across any closed shapes, Fit Headline.
+  - Live effects with previewing dialogs: Distort & Transform, Path, Convert to Shape, 15 Warp styles, Round Corners, Scribble, Effect → Pathfinder (all 10 operations, live on groups; several loose objects are grouped first, in one undo step), Color Adjustments (Brightness/Contrast, Curves, Levels, Hue/Saturation, Shift to Color, Temperature/Tint, on vectors, live type and embedded images), and raster drop shadow, glows and feather. SVG and PDF export keep live effects (geometry baked; SVG raster effects as filters).
+- **Type:** Text Wrap, Type on a Path effects (Rainbow/Skew/3D Ribbon/Stair Step/Gravity), Character and Paragraph Styles (override-preserving redefine), Area Type Options (rows/columns/inset/first baseline), threaded text across any closed shapes, Fit Headline. Area type resizes like Illustrator's type areas: a bounding-box handle drag (Selection tool) or Area Type Options Width/Height size the frame and the text reflows at its size (threads too); Direct Selection drags a frame corner or edge (`text.reshapeArea`). Point type still scales. Variable fonts list every named instance as a style of their family (Figtree Light to Black and their italics, Bahnschrift, Segoe UI Variable), and the instance chosen is shaped, drawn, outlined and measured at its axis settings; PDF and SVG embed it as that instance. Variation axis sliders are not done.
+- **Interface languages, vertical type:** VectorCraft ▸ Language (or Preferences ▸ User Interface) picks Automatic (the system locale) or a registered language, persisted as `interfaceLanguage`. Translations come from per-language catalogs (`i18n/*.tsv`): Traditional Chinese covers the whole interface, Czech and Japanese every menu label (tested); untranslated text stays English. Japanese and Chinese glyphs come from the craft-fonts build input (release builds) or the installed fonts, Czech ones from the bundled UI fonts. Vertical Type, Vertical Area Type and Vertical Type on a Path create vertical text (columns right to left, upright CJK glyphs and marks with `vert` alternates, Latin and longer numbers on their side, two- and three-digit numbers set as tate-chu-yoko in one em of the column (kept whole when justified), upright glyphs centred on the column (tracked or justified too), point type's anchor on the first column's centre line); kinsoku (the strict set) applies to horizontal and vertical Japanese; Type ▸ Type Orientation switches existing text; caret, selection, hit testing and arrow keys follow the writing direction. Vertical text exports to PDF as real text and to SVG as outlines.
 - **Transparency:** opacity masks (clip/invert/disable/link), exported as SVG `<mask>` and PDF soft masks.
-- **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type, Gradient Mesh, Shape Builder, Live Paint, Image Trace (12 presets), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror).
+- **Advanced art:** live Blends (steps/distance/smooth colour, editable spine, anchor-targeted Blend tool, faithful interpolation, knockout), Envelope Distort (warp/mesh/top object, Reset, full Envelope Options, mesh handles, Edit Contents; type, images, symbols, gradients, patterns and appearance distorted everywhere), Liquify tools with options and pen pressure, Puppet Warp with rotating pins, Perspective Grid with presets, movable planes and projected type, Gradient Mesh, Shape Builder, Live Paint (every path an edge, open lines included), Image Trace (12 presets), pattern swatches with pattern editing mode, live Repeat (radial/grid/mirror).
 - **Paint and appearance (M3):**
   - **Swatches:** names follow the colour model and are unique; Swatch Options (process/spot, Global, Gray/RGB/HSB/CMYK/Web, live preview); editing a global or spot swatch recolours every linked fill, stroke and text run in one undo step; multi-select and delete with confirmation; New Swatch and New Color Group dialogs (a group from the selected artwork's colours); swatches in colour groups convert, separate and count like any other. The Swatches panel selects ranges and whole groups, has a find field, and drags swatches to reorder, regroup or paint art; Add Used Colors, Select All Unused, Merge, Ungroup and Sort by Kind; a CMYK document keeps applied colours in CMYK. Swatch libraries: nine generated colour libraries and five gradient libraries in a library panel, saved and loaded as `.vcswatches`, `.gpl` or CSS. Tints of global and spot colours ("Name 40%") stay linked and separate as a percentage of their plate. Spot colours can be defined in Lab (Spot Colors options). A built-in [Registration] swatch prints on every plate.
   - **Colour:** a Color Picker (colour field, H/S/B/R/G/B channel slider, HSB/RGB/Lab/CMYK fields, hex, web-only snapping, out-of-gamut correction); the Color panel follows each colour's own model and Alt-click paints the other proxy; proxies look through groups and show "?" for mixed paint; Invert, Complement, Apply Last Color (`,`) and Apply Last Gradient (`.`) keep the colour model; every paint command feeds the recent colours. The Color Guide has 21 harmony rules, Steps and Variation options and Limit to Library. Adjust Color Balance (its Global mode shifts tints) and Saturate preview live; Edit Colors and Recolor also reach meshes, images and patterns. Recolor Artwork has colour reduction, five recolour methods, presets, Limit to Library, a colour-wheel Edit tab and Edit Color Group; a local Color Themes panel saves five-colour themes. Fill/Stroke chips open swatch and mixer popovers, panels have their shortcuts, and Eyedropper Options pick up and apply chosen attributes (Alt and Shift+Alt, image pixels). Fills and strokes can overprint (Attributes panel, Overprint Black options), and CMYK documents blend in inks on screen, in PDF and when flattening.
@@ -124,12 +135,14 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
   - **Graphic styles:** styles keep opacity and blend mode, capture groups and type, apply on top with Alt, and link to the objects using them; Redefine, Break Link, Graphic Style Options, Select All Unused, Sort by Name, and Select > Same Graphic Style / Appearance Attribute. The panel has list and thumbnail views with rendered previews, merge, reorder and drag and drop, plus a Control bar Style picker; six generated style libraries save and load as `.vcstyles`.
   - **Neutral wording:** labels, MCP tool text, docs and packaging use neutral names, and `cargo xtask brands` (part of `cargo xtask ci`) fails on vendor names.
 - **Colour, type and file workflows:** Recolor Artwork (dialog with harmonies), Edit Colors, Find & Replace, Change Case, Smart Punctuation, Guides, Lock/Hide Above, Transform Each, Rasterize.
+- **Fonts:** a font is found by any of its names (family and style in every language of its name table, legacy family/style pairs, PostScript name), so documents from other apps open with the font they name; Find Font and `text.fonts` say for each font whether it was found exactly, by another name, substituted or missing, and how many glyphs are missing.
 - **Files (M4):**
   - `.vectorcraft` (lossless JSON, compressed, atomic saves, save down to v1), Save As with a format chooser, Save a Copy, Revert, templates, Data Recovery after a crash, background save and export.
-  - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units; PDF and PDF-compatible `.ai` in and out (layers, masks, editable text, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3).
-  - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export.
+  - SVG/SVGZ in and out with SVG Options, Preserve Editing, symbols, filters, rich text and physical units; PDF and PDF-compatible `.ai` in and out (layers, masks, editable text with type set along a curve coming back as type on a path, each artboard's art on its own page only, spot colours, presets, security, marks and bleed, ICC output intents, raster effects, subset fonts, PDF/X, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3).
+  - EPS and DXF in and out, EMF/WMF in and out; PNG (with PNG-8), JPEG, WebP, GIF, TIFF, BMP, Targa and layered PSD export. EPS import runs Illustrator's AGM/CoolType prologs (resource categories, `resourceforall`, `clipsave`/`cliprestore`, subarrays and substrings that share storage) and falls back to its palette TIFF preview. DXF TEXT justified Fit or Aligned spans its two points (stretched, or scaled as a whole).
   - Place and the Links panel, Package, File Info, Print with print presets, PostScript output and print tiling, slices and Save for Web, Export for Screens and Asset Export, CSS Properties, PNG/PDF/SVG/text clipboard flavours.
 - **Performance:** 20k shapes + 1k texts render in 27 ms per full-retina frame (7.8 ms zoomed), 7× faster than the first version. The UI thread never blocks. The web build is 7.1 MB gzipped.
+- **Graphics processor:** the canvas is rasterized on the CPU and the GPU only composites it, so the desktop app asks for the power-saving GPU by default (the integrated one on hybrid-graphics laptops, where presenting from the discrete GPU made the window flicker, #306). Preferences › Performance › Graphics Processor (`gpuPreference`) or `WGPU_POWER_PREF` picks the discrete one; Help › About and `ui.inspect` name the adapter in use.
 - **Tests and robustness:** ~2,840 automated tests: model-based property tests, a junk-parameter sweep over every command, import fuzzing (SVG, PDF, libraries), golden renders, and MCP end-to-end tests over stdio. Shipped code never panics (workspace lints and a rollback safety net; see `docs/development.md`).
 
 ## Milestones and estimates
@@ -143,17 +156,17 @@ grade by behaviour against `plan/illustrator/`, not by whether a menu item exist
 | M4 | Files (native, SVG, PDF, raster, Export for Screens, clipboard interop) | ✅ done (M4.14–M4.98 on 2026-10-05): Save As/Save a Copy/Revert/templates, Data Recovery and background save, SVG import and export fidelity (units, text, symbols, filters, SVGZ, Preserve Editing, SVG Options), PDF import (colours, layers, masks, editable text, security) and export (presets, marks, bleed, ICC and output intent, raster effects, subset fonts, PDF/X-1a, X-3 and X-4, PDF layers, overprint, page thumbnails, fast web view, PDF 1.3), Place and Links, Package, EPS and DXF in and out, EMF/WMF, TIFF/BMP/Targa/PSD/GIF/PNG-8 export, Print and print presets, slices, Save for Web, Asset Export, clipboard flavours, File Info. Left: DWG (use DXF), PSD placement as layers, overprint read back from PDF, polish | 3–6 |
 | M5 | Performance | 🟡 background render + caches + MT done; `vectorcraft-cli bench` and `vectorcraft-cli perf` (budget suite); file format v2 opens 3× faster (50k paths: 722 → 244 ms); raster effects (glows, shadows, blur, feather) no longer force the whole frame single-threaded (filtered offscreen per effect, verified equal to the single-threaded reference); effect-heavy demos need a clean-machine benchmark; dirty-region rendering, GPU backend spike pending | 15–25 |
 | M6 | Path operations (Pathfinder, Shape Builder, offset…) | ✅ mostly done (Boolean precision on almost-horizontal edges fixed and the property tests made deterministic; Shape Builder edge erase, large-offset bug open) | 3–6 |
-| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (searchable) and found by name on open/import, CJK names in the UI, Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects, tab stops + Tabs panel done; tab leaders, spell check, vertical type pending | 45–60 |
+| M7 | Type (point/area/path, editing, styles, OpenType, threading, glyphs) | 🟡 Character/Paragraph Styles, Area Type Options (with Width/Height), type areas resized by their handles and reshaped with Direct Selection, threaded text, Fit Headline, Glyphs, OpenType panel, Find Font, installed system fonts in every font menu (searchable) and found by name on open/import, variable fonts' named instances as styles, CJK names in the UI, input methods (marked text in place, candidate window at the caret; Japanese IME), Text Wrap (offset, invert, both sides of an object; follows edits), Type on a Path effects, tab stops + Tabs panel done; tab leaders, spell check, vertical type pending | 45–60 |
 | M8 | Transform & distort (Puppet Warp, Liquify tools, Envelopes, Blends, Perspective Grid) | ✅ done (M8.1–M8.20 on 2026-10-06, fidelity pass): Liquify Tool Options with one shared brush, pen pressure, hold-to-apply, a safe scope and incremental strokes; tool options that last; Puppet Warp rotation, multi-select, Control bar and a rest-shape session that follows Undo; Width tool on compound paths; Envelope dialogs with preview, Reset with Warp/Mesh, full Envelope Options, type/images/symbols/appearance/gradients/patterns distorted on canvas and in every export, warps that keep their frame, Edit Contents, mesh handles and Control bar; Blend Options, anchor-targeted Blend tool, editable spine, keys picked on the canvas, faithful interpolation and knockout; Perspective Grid with Define Grid, presets, lock/snap/rulers, widgets, the 1–4 plane switch, movable planes, Perspective Selection scale/copy/perpendicular/Transform Again, and type and symbols truly projected with Edit Text. Left: Anti-Alias and Preserve Shape output, warp-envelope point editing, brush interpolation in blends, Free Transform/Scale/Reflect along a rotated box | 2–4 |
 | M9 | Live effects (+ 3D & Materials) | 🟡 2D effects done incl. Effect → Pathfinder and Color Adjustments; SVG Filters, Document Raster Effects Settings, 3D pending | 86–135 |
 | M10 | Brushes, symbols, patterns, Repeat | 🟡 pattern swatches (5 tile types, Pattern Options, editing mode, SVG `<pattern>`/PDF export) and live Repeat (radial/grid/mirror) done; brushes/symbols in progress | 23–37 |
-| M11 | Artboards & views (artboard panel/tool, Trim View, middle-button pan and print tiling done; multiple windows, presentation polish) | 🟡 | 15–25 |
+| M11 | Artboards & views (artboard panel/tool, Trim View, middle-button pan, print tiling and the status bar's artboard navigator done; multiple windows, presentation polish) | 🟡 | 15–25 |
 | M12 | Advanced color & art (CMYK/ICC, separations, Gradient Mesh, Live Paint, Image Trace, Graphs) | 🟡 Gradient Mesh, Live Paint, Image Trace (12 presets, 18 ms/1k² image), Recolor Artwork, colour management (ICC, soft proofing, separations preview), Graphs (all 9 tools, Graph Data/Type, regenerate in place) done; graph Design/Column/Marker designs pending | 6–10 |
 | M13 | Automation (Actions ✅ record/playback, persisted; variables, scripting, batch) | 🟡 | 18–27 |
-| M14 | 1.0 polish (preferences, shortcut editor, workspaces, accessibility, packaging for all OSes) | 🟡 Preferences, shortcut editor, workspaces, a custom title bar on Windows/Linux with a Home button, content-sized dialogs and menus that scroll when longer than the window done; accessibility, Windows/Linux packaging pending | 18–28 |
+| M14 | 1.0 polish (preferences, shortcut editor, workspaces, accessibility, packaging for all OSes) | 🟡 Preferences, shortcut editor (chords with Shift and a punctuation key fire as typed), workspaces, a custom title bar on Windows/Linux with a Home button, content-sized dialogs and menus that scroll when longer than the window done; accessibility, Windows/Linux packaging pending | 18–28 |
 | — | Interaction fidelity pass (every tool's modifiers, Properties panel per context, isolation, nuance) | ⬜ | 60–90 |
 | — | Hardening at scale (big-file corpus, fuzzing, cross-platform + browser QA) | 🟡 | 50–80 |
-| | **Total to full parity** (one agent; re-derived from the [Parity estimate](#parity-estimate) table) | | **~330–515** |
+| | **Total to full parity** (one agent; re-derived from the [Parity estimate](#parity-estimate) table) | | **~320–500** |
 
 ## Parity estimate
 
@@ -171,37 +184,37 @@ about 1–1.5 agent-hours each, so the other rows (estimated on the older scale)
 |---|---:|---:|---|---:|
 | Selection, transform & align tools | 6 | 85% | Free Transform/Scale/Reflect along a rotated box, Start Global Edit, transform nuances (the rotated persistent bounding box is done) | 4–6 |
 | Drawing tools | 7 | 85% | Shaper Groups (merge/punch overlapping shapes), pen/pencil modifier nuances, Touch Type | 10–15 |
-| Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 85% | Live Paint gap options, Shape Builder edge cases | 3–6 |
+| Path operations, Pathfinder, Shape Builder, Live Paint | 5 | 86% | Live Paint gap options, Shape Builder edge cases | 3–6 |
 | Colour, swatches, gradients, patterns, mesh, recolor | 7 | 96% | freeform and mixed spot/process gradients in SVG/PDF (exported as stops or process colours), pattern fills in Expand | 2–4 |
 | Strokes, brushes, width profiles | 5 | 88% | brush options depth, brush libraries (generated in code) | 6–10 |
 | Appearance, transparency, graphic styles, masks | 5 | 98% | raster effect reach in preview bounds (flattener presets apply in PDF, EPS and print) | 1–2 |
 | Live vector effects | 5 | 85% | Outline Object, Pathfinder Hard/Soft Mix and Trap, SVG Filters | 6–10 |
 | Raster effects (Effect Gallery, Document Raster Effects Settings) | 4 | 20% | ~55 Photoshop-style filters (Artistic, Brush Strokes, Distort, Pixelate, Sketch, Stylize, Texture, Video) and the Effect Gallery; Document Raster Effects Settings and raster effects in PDF are done | 28–42 |
 | 3D and Materials | 4 | 0% | Extrude & Bevel, Revolve, Inflate, Rotate, lighting, materials (software renderer) | 50–80 |
-| Type core | 9 | 78% | composer/hyphenation options, Optical Margin Alignment, hidden characters | 15–20 |
-| Type advanced | 4 | 35% | vertical type/CJK, tab leaders, spell check (open dictionary), Touch Type, Retype | 26–35 |
+| Type core | 9 | 78% | composer/hyphenation options, Optical Margin Alignment, hidden characters, Transform Again after a type-area resize (it scales the type), partial selection of type-area anchors by marquee | 15–20 |
+| Type advanced | 4 | 48% | CJK composition for vertical type (ruby, mojikumi, vertical metrics, manual tate-chu-yoko), variable font axis sliders (named instances are styles), tab leaders, spell check (open dictionary), Touch Type, Retype; vertical point/area/path type and Type Orientation have initial support | 20–28 |
 | Symbols, blends, envelopes, Repeat, perspective | 5 | 88% | symbol libraries (original), dynamic symbols, envelope Anti-Alias/Preserve Shape output and warp point editing, brush interpolation in blends (M8 fidelity pass done) | 5–8 |
 | Image Trace, graphs, image tools | 3 | 70% | graph Design/Column/Marker, Create Object Mosaic, Crop Image polish (Vector Halftone is done) | 6–10 |
 | Layers, artboards, document setup | 5 | 80% | Layers panel options depth, artboard presets/rearrange polish (Document Setup and New Document are done) | 5–8 |
 | View & navigation | 3 | 70% | New View/Edit Views, multiple windows/arrange, Snap to Pixel/Glyph (print tiling is done) | 9–14 |
-| Guides, grids, smart guides, snapping, rulers | 3 | 75% | global/video rulers, smart-guide preference depth | 4–8 |
-| File formats | 6 | 85% | DWG (no open spec: DXF instead), PSD placement as layers, the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers and presets are done | 6–10 |
+| Guides, grids, smart guides, snapping, rulers | 3 | 75% | global/video rulers, smart-guide preference depth, ruler-drag modifiers (Shift snaps to ticks, Alt swaps orientation) and dragging existing guides | 4–8 |
+| File formats | 6 | 85% | DWG (no open spec: DXF instead), PSD placement as layers, Illustrator EPS checked against real files (only reduced repros so far), the remaining fidelity polish; EPS, DXF, EMF/WMF, TIFF, BMP, Targa, PSD export, SVGZ, PDF security, PDF/X, PDF layers and presets are done | 6–10 |
 | Export for Screens, Asset Export, slices, Save for Web | 3 | 85% | polish only (all four are done) | 2–4 |
 | Print, colour management, separations, flattener | 3 | 80% | print preview fidelity (flattener presets in PDF and print, overprint in PDF and composite print, Print dialog, presets, PostScript, marks, separations, Print Tiling, print overprint/flattener/bitmap options and printer profile are done) | 1–2 |
 | Automation | 3 | 60% | Variables (data merge), scripting surface, batch | 8–12 |
-| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 78% | Variables, SVG Interactivity, Properties per context, Consolidate All Windows (Links, Asset Export, CSS Properties, Attributes are done) | 15–25 |
+| UI chrome (panels, contextual Properties, workspaces, prefs) | 6 | 78% | Variables, SVG Interactivity, Properties per context, Consolidate All Windows, context menus beyond the canvas (Links, Asset Export, CSS Properties, Attributes and the canvas context menu are done) | 15–25 |
 | Libraries, Links, Package | 2 | 50% | a local Libraries panel (no cloud by design); Links and Package are done | 5–8 |
-| **Feature parity** | **103** | **~75%** | | **~225–345** |
+| **Feature parity** | **103** | **~75%** | | **~210–330** |
 | Interaction-fidelity pass (side by side with Illustrator: every tool modifier, cursor, dialog, Properties context) | | | | 60–90 |
 | Hardening (big-file corpus, fuzzing, cross-platform and browser QA, accessibility, packaging) | | | | 50–80 |
-| **Full parity** | | **~56%** | | **~330–515** |
+| **Full parity** | | **~56%** | | **~320–500** |
 
 With 4–6 agents working on disjoint crates (as the layering allows) the wall-clock time divides by roughly 3.5–4
-(integration, review and shared files such as `menus.rs` serialize some work): **~60–100 h** to feature parity,
-**~85–150 h** to full parity.
+(integration, review and shared files such as `menus.rs` serialize some work): **~55–95 h** to feature parity,
+**~80–145 h** to full parity.
 
-_Inventories (2026-10-05):_ 18 menu items still stubbed (`todo(…)` in `crates/ui-egui/src/menus.rs`); every tool
-implemented except four (Touch Type, vertical type ×3); 51 panel modules; Illustrator-style live
+_Inventories (2026-10-05):_ 16 menu items still stubbed (`todo(…)` in `crates/ui-egui/src/menus.rs`); every tool
+implemented except Touch Type; 51 panel modules; Illustrator-style live
 effects ~44/54, Photoshop-style raster effects ~1/56, 3D 0/5; ~2,840 tests; ~221k lines of Rust.
 
 _Where we already beat Illustrator:_ exact curve booleans, off-thread multithreaded rendering, undo that never runs out,

apps/vectorcraft-cli/src/main.rs

@@ -2,7 +2,7 @@
 //!
 //! ```text
 //! vectorcraft-cli mcp [--connect 127.0.0.1:7979 | --headless]
-//! vectorcraft-cli run [--in FILE] [--cmd id [--params '{json}']]... [--export out.svg|.png|.pdf|.jpg|.webp|.vectorcraft]... [--scale 2]
+//! vectorcraft-cli run [--in FILE] [--cmd id [--params '{json}']]... [--export out.svg]... [--scale 2]
 //! vectorcraft-cli commands
 //! vectorcraft-cli convert IN OUT [--scale 2] [--artboard 0 | --range 1-3,5] [--outline-text]
 //! vectorcraft-cli info FILE
@@ -14,11 +14,41 @@
 use std::io::Write;
 use std::process::ExitCode;
 
+/// `println!` / `print!` that end the program quietly when stdout is closed
+/// (`vectorcraft-cli commands | head`) instead of panicking with "failed printing to stdout:
+/// Broken pipe (os error 32)".
+macro_rules! outln {
+    ($($arg:tt)*) => {{
+        use std::io::Write as _;
+        if let Err(e) = writeln!(std::io::stdout(), $($arg)*) {
+            $crate::stdout_failed(e);
+        }
+    }};
+}
+macro_rules! out {
+    ($($arg:tt)*) => {{
+        use std::io::Write as _;
+        if let Err(e) = write!(std::io::stdout(), $($arg)*) {
+            $crate::stdout_failed(e);
+        }
+    }};
+}
+
 mod perf;
 
 use serde_json::{Value, json};
 use vectorcraft_mcp::{Backend, DEFAULT_ADDR, Headless, Remote, Server};
 
+/// stdout went away. A reader that stopped early (a closed pipe) ends the program quietly, as
+/// ripgrep does; any other write error is reported.
+fn stdout_failed(e: std::io::Error) -> ! {
+    if e.kind() == std::io::ErrorKind::BrokenPipe {
+        std::process::exit(0);
+    }
+    eprintln!("vectorcraft-cli: can't write to stdout: {e}");
+    std::process::exit(1);
+}
+
 const USAGE: &str = "\
 vectorcraft-cli — VectorCraft automation
 
@@ -29,16 +59,17 @@ USAGE:
 
   vectorcraft-cli run [--in FILE] [--cmd ID [--params JSON]]... [--export FILE]... [--scale N]
       Headless batch: open FILE (any readable format) or start a new document, run commands in
-      order, export (.svg, .png, .pdf, .jpg, .webp, .vectorcraft by extension). Prints one JSON result per step.
+      order, export each FILE in the format its extension picks (see Writable formats). Prints one
+      JSON result per step.
 
   vectorcraft-cli commands
       Print the command catalogue as JSON.
 
   vectorcraft-cli convert IN OUT [--scale N] [--artboard I | --range R] [--outline-text]
-      Open IN (any readable format) and export OUT by extension (.svg, .pdf, .png, .jpg, .webp,
-      .vectorcraft). --artboard is 0-based, --range 1-based (\"1-3,5\"); a PDF gets every artboard
-      unless one of them is given, the other formats the first. Live effects are kept;
-      --outline-text writes SVG text as paths.
+      Open IN (any readable format) and export OUT in the format its extension picks (see Writable
+      formats). --artboard is 0-based, --range 1-based (\"1-3,5\"); a PDF gets every artboard
+      unless one of them is given, EPS the bounds of the art, the other formats the first artboard.
+      Live effects are kept; --outline-text writes SVG text as paths.
 
   vectorcraft-cli info FILE
       Print a JSON summary: title, colour mode, units, artboards, object counts by kind, fonts.
@@ -52,9 +83,10 @@ USAGE:
       synthetic N-path document (default 50000). Exits non-zero if a budget is exceeded.
 ";
 
-/// The usage text plus the formats `document.open` reads.
+/// The usage text plus the formats `document.open` reads and `document.export` writes.
 fn usage() -> String {
-    format!("{USAGE}\nReadable formats: .{}\n", vectorcraft_engine::cmd::fileio::OPEN_EXTS.join(", ."))
+    use vectorcraft_engine::cmd::fileio::{OPEN_EXTS, export_extensions};
+    format!("{USAGE}\nReadable formats: .{}\nWritable formats: .{}\n", OPEN_EXTS.join(", ."), export_extensions().join(", ."))
 }
 
 fn main() -> ExitCode {
@@ -68,11 +100,11 @@ fn main() -> ExitCode {
         Some("bench") => bench(&args[1..]),
         Some("perf") => perf::run(&args[1..]),
         Some("-h" | "--help" | "help") | None => {
-            print!("{}", usage());
+            out!("{}", usage());
             Ok(())
         }
         Some("-V" | "--version") => {
-            println!("vectorcraft-cli {}", env!("CARGO_PKG_VERSION"));
+            outln!("vectorcraft-cli {}", env!("CARGO_PKG_VERSION"));
             Ok(())
         }
         Some(other) => Err(format!("unknown subcommand `{other}`\n\n{}", usage())),
@@ -112,6 +144,9 @@ fn mcp(args: &[String]) -> Result<(), String> {
         }
     };
     eprintln!("vectorcraft-cli: MCP server on stdio ({})", backend.describe());
+    // The binary owns the logger, not the library: installing one here keeps an embedder that
+    // uses `vectorcraft_mcp` free to bring its own. Silent until a client sends logging/setLevel.
+    vectorcraft_mcp::logging::install();
     let stdin = std::io::stdin();
     let stdout = std::io::stdout();
     Server::new(backend).serve(stdin.lock(), stdout.lock()).map_err(|e| e.to_string())
@@ -120,7 +155,7 @@ fn mcp(args: &[String]) -> Result<(), String> {
 fn commands() -> Result<(), String> {
     let mut h = Headless::new();
     let v = h.call("engine.commands", json!({}))?;
-    println!("{}", serde_json::to_string_pretty(&v).unwrap_or_default());
+    outln!("{}", serde_json::to_string_pretty(&v).unwrap_or_default());
     Ok(())
 }
 
@@ -146,7 +181,7 @@ fn convert(args: &[String]) -> Result<(), String> {
             json!({"command": "document.export", "params": {"path": output, "scale": scale, "artboard": artboard, "range": range, "outlineText": outline_text}}),
         )
         .map_err(|e| format!("export {output}: {e}"))?;
-    println!("{r}");
+    outln!("{r}");
     Ok(())
 }
 
@@ -162,7 +197,7 @@ fn info(args: &[String]) -> Result<(), String> {
     let artboards: Vec<Value> =
         doc.artboards.iter().map(|a| json!({"name": a.name, "rect": [a.rect.x0, a.rect.y0, a.rect.width(), a.rect.height()]})).collect();
     let v = json!({"file": file, "info": base, "artboards": artboards, "kinds": kinds, "fonts": fonts});
-    println!("{}", serde_json::to_string_pretty(&v).unwrap_or_default());
+    outln!("{}", serde_json::to_string_pretty(&v).unwrap_or_default());
     Ok(())
 }
 
@@ -252,7 +287,7 @@ fn bench(args: &[String]) -> Result<(), String> {
         * vectorcraft_geom::Affine::scale(z)
         * vectorcraft_geom::Affine::translate(-b.center().to_vec2());
     let opts = vectorcraft_render::RenderOptions::default();
-    println!("{file}: {} nodes, {w}x{h}", doc.layers.iter().map(|l| l.count()).sum::<usize>());
+    outln!("{file}: {} nodes, {w}x{h}", doc.layers.iter().map(|l| l.count()).sum::<usize>());
     for threads in [vectorcraft_render::default_threads(), 0] {
         let mut r = vectorcraft_render::Renderer::new();
         r.threads = threads;
@@ -261,7 +296,7 @@ fn bench(args: &[String]) -> Result<(), String> {
         for _ in 0..iters {
             r.render(&doc, w, h, view, &opts);
         }
-        println!(
+        outln!(
             "  threads {threads}: {:.1} ms/frame (drawn {}, culled {})",
             t.elapsed().as_secs_f64() * 1000.0 / iters as f64,
             r.stats.drawn,

apps/vectorcraft-cli/src/perf.rs

@@ -81,14 +81,14 @@ pub fn run(args: &[String]) -> Result<(), String> {
     }
     let cores = std::thread::available_parallelism().map_or(1, |c| c.get());
     let load = load_average();
-    println!("VectorCraft performance budgets — {n} paths, {cores} cores, load average {}", load.map_or("?".into(), |l| format!("{l:.1}")));
+    outln!("VectorCraft performance budgets — {n} paths, {cores} cores, load average {}", load.map_or("?".into(), |l| format!("{l:.1}")));
     let noisy = load.is_some_and(|l| l > cores as f64 * 0.75);
     if noisy {
-        println!("WARNING: the machine is busy; wall-clock timings below are not trustworthy.");
+        outln!("WARNING: the machine is busy; wall-clock timings below are not trustworthy.");
     }
     let t = Instant::now();
     let doc = synthetic(n)?;
-    println!("  (built in {:.0} ms)", t.elapsed().as_secs_f64() * 1000.0);
+    outln!("  (built in {:.0} ms)", t.elapsed().as_secs_f64() * 1000.0);
 
     let mut rows: Vec<(&str, f64, f64)> = vec![];
     let opts = RenderOptions::default();
@@ -150,16 +150,16 @@ pub fn run(args: &[String]) -> Result<(), String> {
     }
 
     let mut over = 0;
-    println!("  {:<40} {:>10} {:>10}", "", "measured", "budget");
+    outln!("  {:<40} {:>10} {:>10}", "", "measured", "budget");
     for (name, ms, budget) in &rows {
         let ok = ms <= budget;
         over += usize::from(!ok);
-        println!("  {name:<40} {ms:>8.2} ms {budget:>7.0} ms  {}", if ok { "ok" } else { "OVER" });
+        outln!("  {name:<40} {ms:>8.2} ms {budget:>7.0} ms  {}", if ok { "ok" } else { "OVER" });
     }
     match (over, noisy) {
         (0, _) => Ok(()),
         (_, true) => {
-            println!("{over} over budget, but the machine is busy: re-run when idle.");
+            outln!("{over} over budget, but the machine is busy: re-run when idle.");
             Ok(())
         }
         _ => Err(format!("{over} budget(s) exceeded")),

apps/vectorcraft-cli/tests/cli.rs

@@ -82,3 +82,17 @@ fn mcp_headless_over_stdio() {
     assert_eq!(replies[2]["result"]["isError"], false);
     assert_eq!(replies[3]["result"]["content"][0]["type"], "image");
 }
+
+/// `vectorcraft-cli commands | head -1` panicked with "failed printing to
+/// stdout: Broken pipe (os error 32)" and exit status 101.
+#[test]
+fn closed_stdout_ends_quietly() {
+    use std::io::Read;
+    let mut child = Command::new(BIN).arg("commands").stdout(Stdio::piped()).stderr(Stdio::piped()).spawn().unwrap();
+    let mut first = [0u8; 16];
+    child.stdout.as_mut().unwrap().read_exact(&mut first).unwrap();
+    drop(child.stdout.take());
+    let out = child.wait_with_output().unwrap();
+    let err = String::from_utf8_lossy(&out.stderr);
+    assert!(out.status.success() && !err.contains("panicked"), "{:?}: {err}", out.status);
+}

apps/vectorcraft/Cargo.toml

@@ -30,6 +30,8 @@ clipboard-win = { workspace = true }
 
 [target.'cfg(target_os = "macos")'.dependencies]
 muda = { version = "0.21", default-features = false }
+objc2 = "0.6"
+objc2-app-kit = { version = "0.3", default-features = false, features = ["std", "NSTextInputContext"] }
 
 [build-dependencies]
 # Icon + VERSIONINFO for vectorcraft.exe; build.rs only uses it when targeting Windows.

apps/vectorcraft/src/control_server.rs

@@ -1,14 +1,28 @@
 //! Loopback JSON-lines control server: one request per line, one reply per line.
 //! This is the transport the MCP server (`vectorcraft mcp --connect`) wraps.
+//!
+//! The server only ever reads requests: a line that is not a JSON object with a string `method`
+//! (an HTTP request line from a browser's cross-origin `fetch`, a stray `nc`, binary junk) gets
+//! one error reply and the connection is closed, so nothing after it is executed. Lines are
+//! bounded ([`MAX_LINE`]) and so is the number of open connections ([`MAX_CONNECTIONS`]); junk
+//! never reaches the UI thread. See `docs/control-protocol.md`.
 
-use std::io::{BufRead, BufReader, Write};
+use std::io::{BufRead, BufReader, Read, Write};
 use std::net::{TcpListener, TcpStream};
+use std::sync::Arc;
+use std::sync::atomic::{AtomicUsize, Ordering};
 use std::sync::mpsc::{Receiver, Sender, channel};
 use std::time::Duration;
 
 use serde_json::{Value, json};
 use vectorcraft_ui_egui::ControlRequest;
 
+/// Longest accepted request line (bytes, without the newline). Requests are small JSON objects;
+/// anything longer is refused and the connection closed.
+pub const MAX_LINE: usize = 4 * 1024 * 1024;
+/// Connections served at once; further ones get an error line and are closed.
+pub const MAX_CONNECTIONS: usize = 16;
+
 pub fn start(port: u16, ctx: egui::Context) -> Receiver<ControlRequest> {
     let (tx, rx) = channel::<ControlRequest>();
     let listener = match TcpListener::bind(("127.0.0.1", port)) {
@@ -19,44 +33,249 @@ pub fn start(port: u16, ctx: egui::Context) -> Receiver<ControlRequest> {
         }
     };
     eprintln!("vectorcraft: control server listening on 127.0.0.1:{port}");
-    std::thread::spawn(move || {
-        for stream in listener.incoming().flatten() {
-            let tx = tx.clone();
-            let ctx = ctx.clone();
-            std::thread::spawn(move || serve(stream, tx, ctx));
-        }
-    });
+    std::thread::spawn(move || accept_loop(listener, tx, ctx));
     rx
 }
 
-fn serve(stream: TcpStream, tx: Sender<ControlRequest>, ctx: egui::Context) {
-    let Ok(read) = stream.try_clone() else { return };
-    let mut out = stream;
-    for line in BufReader::new(read).lines() {
-        let Ok(line) = line else { break };
-        if line.trim().is_empty() {
+fn accept_loop(listener: TcpListener, tx: Sender<ControlRequest>, ctx: egui::Context) {
+    let open = Arc::new(AtomicUsize::new(0));
+    for mut stream in listener.incoming().flatten() {
+        if open.fetch_add(1, Ordering::SeqCst) >= MAX_CONNECTIONS {
+            open.fetch_sub(1, Ordering::SeqCst);
+            // Best effort: the connection is dropped either way, and a peer that can't read the reason loses nothing.
+            let _ = writeln!(stream, "{}", json!({"ok": false, "error": "too many control connections"}));
             continue;
         }
-        let reply = match serde_json::from_str::<Value>(&line) {
-            Ok(msg) => {
-                let id = msg.get("id").cloned().unwrap_or(Value::Null);
-                let method = msg.get("method").and_then(Value::as_str).unwrap_or("").to_string();
-                let params = msg.get("params").cloned().unwrap_or(json!({}));
-                let (req, rrx) = ControlRequest::new(method, params);
-                if tx.send(req).is_err() {
-                    break;
-                }
-                ctx.request_repaint();
-                let mut r = rrx.recv_timeout(Duration::from_secs(60)).unwrap_or_else(|_| json!({"ok": false, "error": "timeout"}));
-                if let Some(o) = r.as_object_mut() {
-                    o.insert("id".into(), id);
+        let tx = tx.clone();
+        let ctx = ctx.clone();
+        let open = Arc::clone(&open);
+        std::thread::spawn(move || {
+            serve(stream, &tx, &ctx);
+            open.fetch_sub(1, Ordering::SeqCst);
+        });
+    }
+}
+
+fn serve(stream: TcpStream, tx: &Sender<ControlRequest>, ctx: &egui::Context) {
+    let Ok(read) = stream.try_clone() else { return };
+    serve_lines(read, stream, |method, params| {
+        let (req, rrx) = ControlRequest::new(method, params);
+        tx.send(req).ok()?;
+        ctx.request_repaint();
+        Some(rrx.recv_timeout(Duration::from_secs(60)).unwrap_or_else(|_| json!({"ok": false, "error": "timeout"})))
+    });
+}
+
+/// One parsed line.
+enum Line {
+    Request {
+        id: Value,
+        method: String,
+        params: Value,
+    },
+    Blank,
+    /// Not a request: reply with this error and close the connection.
+    Reject(String),
+}
+
+fn parse_line(bytes: &[u8]) -> Line {
+    let Ok(text) = std::str::from_utf8(bytes) else {
+        return Line::Reject("not a control request (invalid UTF-8); closing the connection".into());
+    };
+    let text = text.trim();
+    if text.is_empty() {
+        return Line::Blank;
+    }
+    let msg = match serde_json::from_str::<Value>(text) {
+        Ok(v) => v,
+        Err(e) => return Line::Reject(format!("bad JSON ({e}); expected one JSON request object per line; closing the connection")),
+    };
+    let Some(obj) = msg.as_object() else {
+        return Line::Reject("not a control request (expected a JSON object); closing the connection".into());
+    };
+    let Some(method) = obj.get("method").and_then(Value::as_str) else {
+        return Line::Reject("not a control request (missing string `method`); closing the connection".into());
+    };
+    Line::Request {
+        id: obj.get("id").cloned().unwrap_or(Value::Null),
+        method: method.to_string(),
+        params: obj.get("params").cloned().unwrap_or(json!({})),
+    }
+}
+
+/// Read one `\n`-terminated line of at most `max` bytes into `buf` (newline stripped).
+/// `Ok(false)` at end of stream; `Err` when the line is too long or the read fails.
+fn read_bounded_line(reader: &mut impl BufRead, buf: &mut Vec<u8>, max: usize) -> Result<bool, String> {
+    buf.clear();
+    // `take` bounds the bytes buffered for one line: a peer can't make us allocate more than `max`.
+    let limit = u64::try_from(max).unwrap_or(u64::MAX).saturating_add(1);
+    let n = reader.take(limit).read_until(b'\n', buf).map_err(|e| e.to_string())?;
+    if n == 0 {
+        return Ok(false);
+    }
+    if buf.last() == Some(&b'\n') {
+        buf.pop();
+        if buf.last() == Some(&b'\r') {
+            buf.pop();
+        }
+        return Ok(true);
+    }
+    if buf.len() > max {
+        return Err(format!("request line longer than {max} bytes; closing the connection"));
+    }
+    // Last line without a newline, then end of stream.
+    Ok(true)
+}
+
+/// Serve requests from `read`, answering on `out`, until the peer closes, sends something that is
+/// not a request, or `handle` returns `None` (app gone). `handle` gets `(method, params)` and
+/// returns the reply object (the request's `id` is added here).
+fn serve_lines<R: Read, W: Write>(read: R, mut out: W, mut handle: impl FnMut(String, Value) -> Option<Value>) {
+    let mut reader = BufReader::new(read);
+    let mut buf = Vec::new();
+    loop {
+        let reject = match read_bounded_line(&mut reader, &mut buf, MAX_LINE) {
+            Ok(false) => return,
+            Err(e) => e,
+            Ok(true) => match parse_line(&buf) {
+                Line::Blank => continue,
+                Line::Reject(e) => e,
+                Line::Request { id, method, params } => {
+                    let Some(mut r) = handle(method, params) else { return };
+                    if let Some(o) = r.as_object_mut() {
+                        o.insert("id".into(), id);
+                    }
+                    if writeln!(out, "{r}").and_then(|()| out.flush()).is_err() {
+                        return;
+                    }
+                    continue;
                 }
-                r
-            }
-            Err(e) => json!({"ok": false, "error": format!("bad JSON: {e}")}),
+            },
         };
-        if writeln!(out, "{reply}").is_err() {
-            break;
+        // Best effort: the connection closes either way, and a peer that can't read the reason loses nothing.
+        let _ = writeln!(out, "{}", json!({"ok": false, "error": reject})).and_then(|()| out.flush());
+        return;
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn run(input: &[u8]) -> (Vec<Value>, Vec<String>) {
+        let mut out = Vec::new();
+        let mut calls = Vec::new();
+        serve_lines(input, &mut out, |m, _p| {
+            calls.push(m);
+            Some(json!({"ok": true, "result": null}))
+        });
+        let replies = String::from_utf8(out).unwrap().lines().map(|l| serde_json::from_str::<Value>(l).unwrap()).collect();
+        (replies, calls)
+    }
+
+    #[test]
+    fn requests_are_answered_in_order_with_ids() {
+        let (r, calls) = run(b"{\"id\":1,\"method\":\"a\"}\n\n{\"id\":2,\"method\":\"b\",\"params\":{}}\r\n{\"method\":\"c\"}");
+        assert_eq!(calls, ["a", "b", "c"]);
+        assert_eq!(r.len(), 3);
+        assert_eq!(r[0]["id"], 1);
+        assert_eq!(r[1]["id"], 2);
+        assert_eq!(r[2]["id"], Value::Null);
+    }
+
+    #[test]
+    fn http_request_closes_before_the_body_runs() {
+        // A browser's cross-origin `fetch` POST: the request line is rejected and the
+        // connection closed, so the JSON body is never executed.
+        let http = b"POST / HTTP/1.1\r\nHost: 127.0.0.1:7979\r\nOrigin: https://attacker.example\r\nContent-Type: text/plain\r\n\r\n\
+            {\"id\":7,\"method\":\"engine.execute\",\"params\":{\"command\":\"file.new\",\"params\":{}}}\n";
+        let (r, calls) = run(http);
+        assert!(calls.is_empty(), "nothing may run: {calls:?}");
+        assert_eq!(r.len(), 1);
+        assert_eq!(r[0]["ok"], false);
+        assert!(r[0]["error"].as_str().unwrap().contains("closing the connection"));
+    }
+
+    #[test]
+    fn non_request_json_closes_the_connection() {
+        for junk in [
+            &b"[1,2]\n{\"method\":\"a\"}\n"[..],
+            b"{\"id\":1}\n{\"method\":\"a\"}\n",
+            b"{\"method\":5}\n{\"method\":\"a\"}\n",
+            b"\xff\xfe\n{\"method\":\"a\"}\n",
+        ] {
+            let (r, calls) = run(junk);
+            assert!(calls.is_empty(), "{calls:?}");
+            assert_eq!(r.len(), 1);
+            assert_eq!(r[0]["ok"], false);
         }
+    }
+
+    #[test]
+    fn a_request_before_junk_still_runs() {
+        let (r, calls) = run(b"{\"method\":\"a\"}\nGET / HTTP/1.1\n{\"method\":\"b\"}\n");
+        assert_eq!(calls, ["a"]);
+        assert_eq!(r.len(), 2);
+        assert_eq!(r[1]["ok"], false);
+    }
+
+    #[test]
+    fn overlong_line_is_refused() {
+        // One byte over the limit, then a valid request: neither runs.
+        let mut input = vec![b'x'; MAX_LINE + 1];
+        input.extend_from_slice(b"\n{\"method\":\"a\"}\n");
+        let (r, calls) = run(&input);
+        assert!(calls.is_empty(), "{calls:?}");
+        assert_eq!(r.len(), 1);
+        assert!(r[0]["error"].as_str().unwrap().contains("longer than"));
+    }
+
+    #[test]
+    fn line_at_the_limit_is_accepted() {
+        let mut buf = Vec::new();
+        let line = vec![b'a'; 10];
+        let mut input = line.clone();
+        input.push(b'\n');
+        assert_eq!(read_bounded_line(&mut &input[..], &mut buf, 10), Ok(true));
+        assert_eq!(buf, line);
+        assert!(read_bounded_line(&mut &[b'a'; 11][..], &mut buf, 10).is_err());
+    }
+
+    #[test]
+    fn tcp_connection_is_closed_after_junk() {
+        // End to end over a real loopback socket (the transport the app uses).
+        let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
+        let addr = listener.local_addr().unwrap();
+        let server = std::thread::spawn(move || {
+            let (s, _) = listener.accept().unwrap();
+            let read = s.try_clone().unwrap();
+            serve_lines(read, s, |_, _| Some(json!({"ok": true})));
+        });
+        let mut c = TcpStream::connect(addr).unwrap();
+        c.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
+        c.write_all(b"{\"id\":7,\"method\":\"x\"}\nhello\n{\"method\":\"y\"}\n").unwrap();
+        let mut text = String::new();
+        c.read_to_string(&mut text).unwrap(); // returns at EOF: the server closed the connection
+        server.join().unwrap();
+        let lines: Vec<&str> = text.lines().collect();
+        assert_eq!(lines.len(), 2, "{text}");
+        assert!(lines[0].contains("\"id\":7"));
+        assert!(lines[1].contains("closing the connection"));
+    }
+
+    #[test]
+    fn extra_connections_are_refused() {
+        let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
+        let addr = listener.local_addr().unwrap();
+        let (tx, _rx) = channel::<ControlRequest>();
+        std::thread::spawn(move || accept_loop(listener, tx, egui::Context::default()));
+        // Idle connections are accepted in order and held open.
+        let held: Vec<TcpStream> = (0..16).map(|_| TcpStream::connect(addr).unwrap()).collect();
+        let mut extra = TcpStream::connect(addr).unwrap();
+        extra.set_read_timeout(Some(Duration::from_secs(5))).unwrap();
+        let mut line = String::new();
+        BufReader::new(&mut extra).read_line(&mut line).unwrap();
+        assert!(line.contains("too many control connections"), "{line}");
+        drop(held);
     }
 }

apps/vectorcraft/src/main.rs

@@ -5,6 +5,7 @@
 //! `--control <port>` (or `VECTORCRAFT_CONTROL_PORT`) starts a localhost JSON-lines control server:
 //! `{"id":1,"method":"ui.inspect","params":{}}` → `{"id":1,"ok":true,"result":…}`.
 //! See `vectorcraft_ui_egui::control` for the methods.
+#![cfg_attr(all(target_os = "windows", not(debug_assertions)), windows_subsystem = "windows")]
 
 mod clipboard;
 mod control_server;
@@ -41,12 +42,27 @@ impl eframe::App for App {
     }
     fn ui(&mut self, ui: &mut egui::Ui, _frame: &mut eframe::Frame) {
         self.0.ui(ui);
+        #[cfg(target_os = "macos")]
+        if self.0.take_ime_discard() {
+            discard_marked_text();
+        }
     }
     fn on_exit(&mut self) {
         save_prefs(&self.0);
     }
 }
 
+/// Tell the macOS input method to drop its composition (the Type tool kept the marked text as
+/// typed). winit's IME toggle only clears its own copy, so the IME would type it again.
+#[cfg(target_os = "macos")]
+fn discard_marked_text() {
+    if let Some(mtm) = objc2::MainThreadMarker::new()
+        && let Some(ic) = objc2_app_kit::NSTextInputContext::currentInputContext(mtm)
+    {
+        ic.discardMarkedText();
+    }
+}
+
 /// Where UI preferences live: ~/Library/Application Support/VectorCraft (macOS),
 /// %APPDATA%\VectorCraft (Windows), $XDG_CONFIG_HOME or ~/.config/vectorcraft (Linux).
 fn prefs_path() -> Option<std::path::PathBuf> {
@@ -225,11 +241,33 @@ fn app_icon() -> egui::IconData {
     eframe::icon_data::from_png_bytes(png).unwrap_or_default()
 }
 
+/// The power preference wgpu picks the window's graphics adapter with (#306): the
+/// `WGPU_POWER_PREF` environment variable (`low`, `high`, `none`) when set, otherwise Preferences ›
+/// Performance › Graphics Processor (`gpuPreference`). Power saving unless the preference asks for
+/// high performance: the canvas is rasterized on the CPU and the GPU only composites it, which the
+/// integrated GPU of a hybrid-graphics laptop does easily, while presenting frames rendered on the
+/// discrete GPU through the integrated one made the window flicker on some laptops. With a single
+/// GPU both preferences pick it.
+fn power_preference(pref: Option<&str>, env: Option<eframe::wgpu::PowerPreference>) -> eframe::wgpu::PowerPreference {
+    use eframe::wgpu::PowerPreference;
+    match (env, pref) {
+        (Some(p), _) => p,
+        (None, Some("highPerformance")) => PowerPreference::HighPerformance,
+        (None, _) => PowerPreference::LowPower,
+    }
+}
+
+/// "name (backend, kind)" of the adapter the window renders with, for Help › About and bug reports.
+fn adapter_summary(info: &eframe::wgpu::AdapterInfo) -> String {
+    format!("{} ({:?}, {:?})", info.name.trim(), info.backend, info.device_type)
+}
+
 /// Windows and Linux: no OS title bar; the app bar is the title bar (`vectorcraft_ui_egui::titlebar`).
 /// macOS keeps its traffic lights over the integrated title strip.
 const CUSTOM_TITLEBAR: bool = !cfg!(target_os = "macos");
 
 fn main() -> eframe::Result {
+    vectorcraft_ui_egui::i18n::detect_system_lang_in_background();
     let mut control_port: Option<u16> = std::env::var("VECTORCRAFT_CONTROL_PORT").ok().and_then(|p| p.parse().ok());
     let mut files = Vec::new();
     let mut args = std::env::args().skip(1);
@@ -245,7 +283,9 @@ fn main() -> eframe::Result {
     }
     let saved = read_prefs();
     let saved_window = saved.as_ref().and_then(|ui| ui.window);
-    let options = eframe::NativeOptions {
+    let gpu_pref = saved.as_ref().and_then(|ui| ui.engine_prefs.get("gpuPreference")).and_then(serde_json::Value::as_str);
+    let power = power_preference(gpu_pref, eframe::wgpu::PowerPreference::from_env());
+    let mut options = eframe::NativeOptions {
         viewport: egui::ViewportBuilder::default()
             .with_title("VectorCraft")
             .with_inner_size(window::DEFAULT_SIZE)
@@ -259,6 +299,9 @@ fn main() -> eframe::Result {
             .with_app_id("ai.storyteller.vectorcraft"),
         ..Default::default()
     };
+    if let eframe::egui_wgpu::WgpuSetup::CreateNew(create) = &mut options.wgpu_options.wgpu_setup {
+        create.power_preference = power;
+    }
     eframe::run_native(
         "VectorCraft",
         options,
@@ -280,6 +323,11 @@ fn main() -> eframe::Result {
                 let recovery = prefs_path().and_then(|p| Some(p.parent()?.join("Data Recovery").to_string_lossy().to_string()));
                 app.session.recovery.set_default_folder(recovery);
             }
+            if let Some(rs) = &cc.wgpu_render_state {
+                let summary = adapter_summary(&rs.adapter.get_info());
+                log::info!("vectorcraft: rendering with {summary} (power preference {power:?})");
+                app.graphics_adapter = Some(summary);
+            }
             app.integrated_titlebar = cfg!(target_os = "macos");
             app.custom_titlebar = CUSTOM_TITLEBAR;
             if let Some(port) = control_port {
@@ -299,3 +347,35 @@ fn main() -> eframe::Result {
         }),
     )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use eframe::wgpu::PowerPreference;
+
+    #[test]
+    fn power_saving_unless_the_preference_or_the_environment_says_otherwise() {
+        assert_eq!(power_preference(None, None), PowerPreference::LowPower);
+        assert_eq!(power_preference(Some("powerSaving"), None), PowerPreference::LowPower);
+        assert_eq!(power_preference(Some("highPerformance"), None), PowerPreference::HighPerformance);
+        // A value this version doesn't know (a newer or damaged preference file) is the default.
+        assert_eq!(power_preference(Some("turbo"), None), PowerPreference::LowPower);
+        assert_eq!(power_preference(Some(""), None), PowerPreference::LowPower);
+        // WGPU_POWER_PREF wins over the preference, either way.
+        assert_eq!(power_preference(Some("powerSaving"), Some(PowerPreference::HighPerformance)), PowerPreference::HighPerformance);
+        assert_eq!(power_preference(Some("highPerformance"), Some(PowerPreference::LowPower)), PowerPreference::LowPower);
+        assert_eq!(power_preference(None, Some(PowerPreference::None)), PowerPreference::None);
+    }
+
+    /// The preference the engine saves is the one the app reads back before the window opens.
+    #[test]
+    fn the_saved_engine_preference_is_found() {
+        let mut prefs = vectorcraft_engine::Prefs::default();
+        let saved = prefs.to_json();
+        assert_eq!(saved.get("gpuPreference").and_then(serde_json::Value::as_str), Some("powerSaving"));
+        prefs.gpu_preference = "highPerformance".into();
+        let saved = prefs.to_json();
+        let pref = saved.get("gpuPreference").and_then(serde_json::Value::as_str);
+        assert_eq!(power_preference(pref, None), PowerPreference::HighPerformance);
+    }
+}

apps/vectorcraft/src/native_menu.rs

@@ -10,6 +10,7 @@ use muda::accelerator::Accelerator;
 use muda::{CheckMenuItem, Menu, MenuEvent, MenuItem, PredefinedMenuItem, Submenu};
 use serde_json::Value;
 use vectorcraft_ui_egui::VectorcraftApp;
+use vectorcraft_ui_egui::i18n::{self, Lang, t};
 use vectorcraft_ui_egui::menus::{self, Item};
 
 enum Handle {
@@ -27,6 +28,8 @@ pub struct NativeMenu {
     slots: usize,
     /// Plug-in registry revision the Plug-ins submenus were built for.
     plugins: u64,
+    /// The language the labels were built in (a change rebuilds the menu).
+    language: Lang,
 }
 
 /// Accelerator for a shortcut like "Cmd+Shift+]" (modifier-less shortcuts stay in the app so they
@@ -47,7 +50,7 @@ impl NativeMenu {
         let mut items = HashMap::new();
         let mut counter = 0usize;
         for (title, entries) in menus::menu_tree() {
-            let sub = Submenu::new(title, true);
+            let sub = Submenu::new(t(title), true);
             build(app, &sub, &entries, &mut items, &mut counter);
             let _ = menu.append(&sub);
         }
@@ -58,7 +61,15 @@ impl NativeMenu {
             .filter(|(_, p, _, c)| (p.is_null() || p.as_object().is_some_and(|o| o.is_empty())) && menus::shortcut_of(c).and_then(accel).is_some())
             .map(|(_, _, _, c)| c.clone())
             .collect();
-        Self { _menu: menu, items, last_refresh: 0.0, generation, slots: menus::listed_slots(app), plugins: menus::plugin_revision() }
+        Self {
+            _menu: menu,
+            items,
+            last_refresh: 0.0,
+            generation,
+            slots: menus::listed_slots(app),
+            plugins: menus::plugin_revision(),
+            language: i18n::current(),
+        }
     }
 
     /// Dispatch clicked items and refresh state.
@@ -74,11 +85,12 @@ impl NativeMenu {
             return;
         }
         self.last_refresh = now;
-        // Shortcuts edited, workspaces added, saved views, recent files or plug-ins changed: rebuild so
-        // accelerators and lists are current.
+        // Shortcuts edited, workspaces added, saved views, recent files, plug-ins or the UI language
+        // changed: rebuild so accelerators, lists and labels are current.
         if vectorcraft_ui_egui::shortcut_editor::GENERATION.load(std::sync::atomic::Ordering::Relaxed) != self.generation
             || menus::listed_slots(app) != self.slots
             || menus::plugin_revision() != self.plugins
+            || i18n::current() != self.language
         {
             *self = NativeMenu::install(app);
             return;
@@ -111,7 +123,7 @@ impl NativeMenu {
                             "view.cornerWidget" | "view.textThreads" | "view.gradientAnnotator" | "effect.last" | "type.hiddenCharacters"
                         )
                     {
-                        i.set_text(menus::dynamic_label(app, cmd, ""));
+                        i.set_text(menus::display_label(app, cmd, ""));
                     }
                 }
                 Handle::Check(c) => {
@@ -136,13 +148,13 @@ fn build(
                 let _ = parent.append(&PredefinedMenuItem::separator());
             }
             Item::Header(h) => {
-                let _ = parent.append(&MenuItem::new(*h, false, None));
+                let _ = parent.append(&MenuItem::new(t(h), false, None));
             }
             Item::Todo(label, sc) => {
-                let _ = parent.append(&MenuItem::new(*label, false, accel(sc)));
+                let _ = parent.append(&MenuItem::new(t(label), false, accel(sc)));
             }
             Item::Sub(label, children) => {
-                let sub = Submenu::new(*label, true);
+                let sub = Submenu::new(t(label), true);
                 build(app, &sub, children, items, counter);
                 let _ = parent.append(&sub);
             }
@@ -153,11 +165,11 @@ fn build(
                 let id = format!("dc{counter}");
                 let sc = if params.is_null() { menus::shortcut_of(cmd).and_then(accel) } else { None };
                 let handle = if menus::checked(app, cmd, params).is_some() {
-                    let c = CheckMenuItem::with_id(id.clone(), *label, true, false, sc);
+                    let c = CheckMenuItem::with_id(id.clone(), menus::display_label(app, cmd, label), true, false, sc);
                     let _ = parent.append(&c);
                     Handle::Check(c)
                 } else {
-                    let i = MenuItem::with_id(id.clone(), *label, true, sc);
+                    let i = MenuItem::with_id(id.clone(), menus::display_label(app, cmd, label), true, sc);
                     let _ = parent.append(&i);
                     Handle::Plain(i)
                 };

crates/cad/src/import/build.rs

@@ -13,7 +13,7 @@ use vectorcraft_doc::{Appearance, AppearanceItem, CharStyle, Dash, Document, LAY
 use vectorcraft_geom::{Affine, FillRule, PathData, Point, Rect};
 
 use super::ImportOptions;
-use super::entity::{Alpha, Col, Converter, Geom, InsertItem, Item, Lw, Props, TextItem};
+use super::entity::{Alpha, Col, Converter, Geom, InsertItem, Item, Lw, Props, Span, TextItem};
 use super::reader::{Drawing, LayoutDef};
 use crate::{CAP_HEIGHT, MAX_NEST};
 
@@ -244,14 +244,18 @@ impl<'d, 'a> Build<'d, 'a> {
             Geom::Text(t) => {
                 let lines = t.text.lines().count().max(1) as f64;
                 let longest = t.text.lines().map(|l| l.chars().count()).max().unwrap_or(0) as f64;
-                let w = longest * t.height * 0.9 * t.width;
+                let natural = longest * t.height * 0.9 * t.width;
+                // Fit and aligned text run their span; aligned text's height scales with it.
+                let k = t.span.and_then(|sp| sp.scale(natural)).unwrap_or(1.0);
+                let height = if matches!(t.span, Some(Span::Aligned(_))) { t.height * k } else { t.height };
+                let w = natural * k;
                 let x0 = match t.justify {
                     vectorcraft_doc::Justify::Center => -w / 2.0,
                     vectorcraft_doc::Justify::Right => -w,
                     _ => 0.0,
                 };
-                let below = (lines - 1.0) * t.leading.unwrap_or(0.0) + t.height * 0.3;
-                Some(t.xf.transform_rect_bbox(Rect::new(x0, -below, x0 + w, t.height)))
+                let below = (lines - 1.0) * t.leading.unwrap_or(0.0) + height * 0.3;
+                Some(t.xf.transform_rect_bbox(Rect::new(x0, -below, x0 + w, height)))
             }
             Geom::Insert(ins) => {
                 let b = self.block_bounds(&ins.block, depth);
@@ -502,6 +506,9 @@ impl<'d, 'a> Build<'d, 'a> {
         let mut obj = TextObject::point(Point::ZERO, &t.text, style);
         obj.xf = m * Affine::scale(1.0 / s);
         obj.para.justify = t.justify;
+        if let Some(span) = t.span {
+            fill_span(&mut obj, span, s);
+        }
         Some(Node::new(self.doc.alloc_id(), NodeKind::Text(Box::new(obj))))
     }
 
@@ -581,6 +588,20 @@ impl<'d, 'a> Build<'d, 'a> {
     }
 }
 
+/// Fit text stretched or squeezed across, aligned text scaled as a whole, to run its span
+/// (`s`: points per drawing unit), measured in the font it is set in.
+fn fill_span(obj: &mut TextObject, span: Span, s: f64) {
+    let layout = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), obj);
+    let natural = layout.lines.iter().map(|l| l.x1 - l.x0).fold(0.0, f64::max);
+    let Some(k) = span.scale(natural / s) else { return };
+    for r in &mut obj.runs {
+        match span {
+            Span::Fit(_) => r.style.h_scale *= k,
+            Span::Aligned(_) => r.style.size *= k,
+        }
+    }
+}
+
 fn rgb_color([r, g, b]: [u8; 3]) -> Color {
     Color::rgb8(r, g, b)
 }

crates/cad/src/import/entity.rs

@@ -19,6 +19,9 @@ const LINE_SPACING: f64 = 5.0 / 3.0;
 const MAX_CELLS: i64 = 10_000;
 /// Art farther than this from the origin (drawing units) is damaged data, left out.
 const MAX_COORD: f64 = 1e12;
+/// How far fit and aligned text may be squeezed or stretched to span their two points: at width
+/// factor 1, the 1 to 10,000% horizontal scale the Character panel allows.
+const SPAN_SCALE: (f64, f64) = (0.01, 100.0);
 
 /// The colour of index `i` on paper: index 7 (white on a CAD screen) is black.
 pub(crate) fn aci_paper(i: u64) -> [u8; 3] {
@@ -121,6 +124,27 @@ pub(crate) struct TextItem {
     pub family: Option<String>,
     /// Baseline-to-baseline distance (drawing units), for several lines.
     pub leading: Option<f64>,
+    /// The distance aligned and fit text run along their baseline.
+    pub span: Option<Span>,
+}
+
+/// How text fills the distance between its two points (drawing units).
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) enum Span {
+    /// Stretched or squeezed across, its height kept.
+    Fit(f64),
+    /// Scaled as a whole, height included.
+    Aligned(f64),
+}
+
+impl Span {
+    /// The scale that makes text `natural` long run the span, within [`SPAN_SCALE`] (None when
+    /// either length is degenerate).
+    pub fn scale(self, natural: f64) -> Option<f64> {
+        let (Self::Fit(d) | Self::Aligned(d)) = self;
+        let k = d / natural;
+        (k.is_finite() && k > 0.0).then(|| k.clamp(SPAN_SCALE.0, SPAN_SCALE.1))
+    }
 }
 
 /// A block reference: one transform per copy (an array insert makes several), each from the
@@ -608,10 +632,13 @@ fn text(g: &[Pair<'_>], attrib: bool) -> Option<TextItem> {
     let (h, v) = (g.int_or(72, 0), g.int_or(if attrib { 74 } else { 73 }, 0));
     let (p1, p2) = (g.point(10), g.point_opt(11));
     let mut angle = g.num_or(50, 0.0).to_radians();
+    let mut span = None;
     // Aligned and fit text run from the first point to the second.
     let anchor = match (h, p2) {
         (3 | 5, Some(p)) => {
             angle = (p - p1).atan2();
+            let d = p1.distance(p);
+            span = (d > 1e-12).then_some(if h == 3 { Span::Aligned(d) } else { Span::Fit(d) });
             p1
         }
         (0, _) if v == 0 => p1,
@@ -636,6 +663,7 @@ fn text(g: &[Pair<'_>], attrib: bool) -> Option<TextItem> {
         style: g.name(7).unwrap_or("STANDARD").to_uppercase(),
         family: None,
         leading: None,
+        span,
     })
 }
 
@@ -662,5 +690,15 @@ fn mtext(g: &[Pair<'_>]) -> Option<TextItem> {
     let direction = g.point_opt(11).map(|p| p.to_vec2()).filter(|d| d.hypot() > 1e-12);
     let angle = direction.map_or_else(|| g.num_or(50, 0.0), |d| d.atan2());
     let xf = Affine::translate(g.point(10).to_vec2()) * Affine::rotate(angle) * Affine::translate((0.0, first));
-    Some(TextItem { text: s, height, xf, width: 1.0, justify, style: g.name(7).unwrap_or("STANDARD").to_uppercase(), family, leading: Some(leading) })
+    Some(TextItem {
+        text: s,
+        height,
+        xf,
+        width: 1.0,
+        justify,
+        style: g.name(7).unwrap_or("STANDARD").to_uppercase(),
+        family,
+        leading: Some(leading),
+        span: None,
+    })
 }

crates/cad/src/import/tests.rs

@@ -397,6 +397,167 @@ fn text_and_multiline_text() {
     assert!((leading - 3.5 * 5.0 / 3.0).abs() < 1e-9, "{leading}");
 }
 
+/// Where the first line's baseline starts and ends, in document coordinates.
+fn baseline_ends(t: &TextObject) -> (Point, Point) {
+    let layout = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
+    let l = &layout.lines[0];
+    (t.xf * Point::new(l.x0, l.baseline), t.xf * Point::new(l.x1, l.baseline))
+}
+
+#[test]
+fn fit_and_aligned_text_span_their_two_points() {
+    // Millimetres: red lines at x = 10 and 90, fit and aligned text between them, and the same
+    // text left-justified for its natural size.
+    let e = [
+        (0, "LINE"),
+        (62, "1"),
+        (10, "10"),
+        (20, "0"),
+        (11, "10"),
+        (21, "60"),
+        (0, "LINE"),
+        (62, "1"),
+        (10, "90"),
+        (20, "0"),
+        (11, "90"),
+        (21, "60"),
+        (0, "TEXT"),
+        (10, "10"),
+        (20, "40"),
+        (40, "5"),
+        (1, "FIT BETWEEN"),
+        (72, "5"),
+        (11, "90"),
+        (21, "40"),
+        (0, "TEXT"),
+        (10, "10"),
+        (20, "10"),
+        (40, "5"),
+        (41, "0.8"),
+        (1, "ALIGNED"),
+        (72, "3"),
+        (11, "90"),
+        (21, "10"),
+        (0, "TEXT"),
+        (10, "10"),
+        (20, "25"),
+        (40, "5"),
+        (1, "FIT BETWEEN"),
+        (0, "TEXT"),
+        (10, "10"),
+        (20, "50"),
+        (40, "5"),
+        (41, "0.8"),
+        (1, "ALIGNED"),
+    ];
+    let o = ImportOptions { center: false, ..ImportOptions::default() };
+    let doc = open(&drawing(&[(9, "$INSUNITS"), (70, "4")], &[], &[], &e), &o).document;
+    let [left, right, fit, aligned, fit_natural, aligned_natural] = &leaves(&doc)[..] else { panic!() };
+    let (x10, x90) = (bounds(left).center().x, bounds(right).center().x);
+    for n in [fit, aligned] {
+        let (a, b) = baseline_ends(text_of(n));
+        assert!((a.x - x10).abs() < 1e-3 && (b.x - x90).abs() < 1e-3, "{a:?} to {b:?}, not {x10} to {x90}");
+        assert!((a.y - b.y).abs() < 1e-9, "level");
+    }
+    // Fit keeps its height and stretches across.
+    let (st, natural) = (text_of(fit).first_style(), text_of(fit_natural).first_style());
+    assert_eq!(st.size, natural.size);
+    assert!(st.h_scale > 100.0, "{}", st.h_scale);
+    // Aligned grows as a whole, its width factor kept.
+    let (a, b) = baseline_ends(text_of(aligned_natural));
+    let k = (x90 - x10) / (b.x - a.x);
+    let (st, natural) = (text_of(aligned).first_style(), text_of(aligned_natural).first_style());
+    assert!((st.size - natural.size * k).abs() < 1e-6 && k > 2.0, "{} vs {} × {k}", st.size, natural.size);
+    assert!((st.h_scale - 80.0).abs() < 1e-9 && (natural.h_scale - 80.0).abs() < 1e-9);
+}
+
+#[test]
+fn fit_and_aligned_text_without_a_second_point_keep_their_size() {
+    for h in ["3", "5"] {
+        let e = [
+            (0, "TEXT"),
+            (10, "10"),
+            (20, "10"),
+            (40, "7"),
+            (1, "Gap"),
+            (72, h),
+            (0, "TEXT"),
+            (10, "10"),
+            (20, "30"),
+            (40, "7"),
+            (1, "Gap"),
+            (72, h),
+            (11, "10"),
+            (21, "30"),
+        ];
+        let doc = open(&entities(&e), &points()).document;
+        let top = height(&doc);
+        for (n, y) in leaves(&doc).iter().zip([10.0, 30.0]) {
+            let t = text_of(n);
+            let st = t.first_style();
+            assert!((st.size - 10.0).abs() < 1e-9 && st.h_scale == 100.0, "{} at {}%", st.size, st.h_scale);
+            assert!((t.xf * Point::ZERO).distance(Point::new(10.0, top - y)) < 1e-9);
+        }
+    }
+}
+
+#[test]
+fn fit_and_aligned_text_scale_within_limits() {
+    // A span a billion units long and one a millionth of a unit long.
+    let e = [
+        (0, "TEXT"),
+        (10, "0"),
+        (20, "0"),
+        (40, "7"),
+        (1, "X"),
+        (72, "5"),
+        (11, "1e9"),
+        (21, "0"),
+        (0, "TEXT"),
+        (10, "0"),
+        (20, "10"),
+        (40, "7"),
+        (1, "X"),
+        (72, "3"),
+        (11, "1e-6"),
+        (21, "10"),
+    ];
+    let doc = open(&entities(&e), &points()).document;
+    let [fit, aligned] = &leaves(&doc)[..] else { panic!() };
+    let st = text_of(fit).first_style();
+    assert!((st.size - 10.0).abs() < 1e-9 && (st.h_scale - 10_000.0).abs() < 1e-6, "{} at {}%", st.size, st.h_scale);
+    let st = text_of(aligned).first_style();
+    assert!((st.size - 0.1).abs() < 1e-9 && st.h_scale == 100.0, "{} at {}%", st.size, st.h_scale);
+}
+
+#[test]
+fn fit_attributes_span_their_two_points() {
+    let inserts = [
+        (0, "INSERT"),
+        (66, "1"),
+        (2, "Door"),
+        (10, "0"),
+        (20, "0"),
+        (0, "ATTRIB"),
+        (10, "10"),
+        (20, "20"),
+        (40, "7"),
+        (1, "D-01"),
+        (2, "TAG"),
+        (70, "0"),
+        (72, "5"),
+        (74, "0"),
+        (11, "90"),
+        (21, "20"),
+        (0, "SEQEND"),
+    ];
+    let doc = open(&with_door(DOOR_LINE, &inserts), &points()).document;
+    let tag = leaves(&doc).into_iter().find(|n| matches!(n.kind, NodeKind::Text(_))).unwrap();
+    let (a, b) = baseline_ends(text_of(&tag));
+    assert!((a.x - 10.0).abs() < 1e-3 && (b.x - 90.0).abs() < 1e-3, "{a:?} to {b:?}");
+    assert_eq!(text_of(&tag).first_style().size, 10.0);
+}
+
 /// A block "Door" (base point 5, 5) holding `block_art`, and `inserts`.
 fn with_door(block_art: &[(i32, &'static str)], inserts: &[(i32, &'static str)]) -> Vec<u8> {
     let mut blocks = vec![(0, "BLOCK"), (8, "0"), (2, "Door"), (70, "0"), (10, "5"), (20, "5"), (3, "Door")];

crates/doc/src/node.rs

@@ -75,12 +75,16 @@ impl LayerColor {
 #[serde(tag = "shape", rename_all = "lowercase")]
 pub enum LiveShape {
     Rectangle {
-        /// Untransformed width/height.
+        /// Untransformed width/height. Transforms fold their scale into these (see
+        /// [`LiveShape::transform`]), so they are document lengths unless `xf` shears.
         w: f64,
         h: f64,
-        /// Corner radii: top-left, top-right, bottom-right, bottom-left.
+        /// Corner radii: top-left, top-right, bottom-right, bottom-left. In the same units as
+        /// `w`/`h`: the corners are circular arcs in the document whenever `xf` doesn't scale.
         radii: [f64; 4],
-        /// Maps the untransformed shape (origin at its top-left) into the document.
+        /// Maps the untransformed shape (origin at its top-left) into the document. A rotation
+        /// or reflection plus a move, unless a shear (or a file saved before transforms folded
+        /// their scale into `w`/`h`) put more in it.
         xf: Affine,
     },
     Ellipse {
@@ -129,12 +133,44 @@ impl LiveShape {
             LiveShape::Line { a, b } => shapes::line(*a, *b),
         }
     }
-    pub fn transform(&mut self, a: Affine) {
+    /// Apply `a` to the shape. True when the shape is no longer `a` applied to the old path, so
+    /// the caller must regenerate the path with [`LiveShape::to_path`].
+    ///
+    /// A rectangle keeps round corners whatever its proportions: when `a` scales it along its own
+    /// sides (any rotation or reflection, no shear), the scale goes into `w`/`h` and `xf` keeps
+    /// only the rotation, reflection and position. The radii scale by the mean scale (the square
+    /// root of the determinant), which [`LiveShape::keep_corners`] undoes for Scale Corners off.
+    /// A shear can't keep circular corners: `xf` takes it, as do moves (so files saved with a
+    /// scale in `xf` keep their exact geometry until they're next transformed).
+    pub fn transform(&mut self, a: Affine) -> bool {
         match self {
-            LiveShape::Rectangle { xf, .. } | LiveShape::Ellipse { xf, .. } | LiveShape::Polygon { xf, .. } => *xf = a * *xf,
+            LiveShape::Rectangle { w, h, radii, xf } => {
+                let m = a * *xf;
+                let [a0, a1, a2, a3, _, _] = a.as_coeffs();
+                let moves_only = (a0 - 1.0).abs() < 1e-12 && a1.abs() < 1e-12 && a2.abs() < 1e-12 && (a3 - 1.0).abs() < 1e-12;
+                let [m0, m1, m2, m3, m4, m5] = m.as_coeffs();
+                let (sx, sy) = (m0.hypot(m1), m2.hypot(m3));
+                let orthogonal = sx > 1e-12 && sy > 1e-12 && (m0 * m2 + m1 * m3).abs() <= 1e-9 * sx * sy;
+                let finite = m.as_coeffs().iter().all(|c| c.is_finite()) && w.is_finite() && h.is_finite();
+                if moves_only || !orthogonal || !finite {
+                    *xf = m;
+                    return false;
+                }
+                let k = (sx * sy).sqrt();
+                radii.iter_mut().for_each(|r| *r *= k);
+                *w *= sx;
+                *h *= sy;
+                *xf = Affine::new([m0 / sx, m1 / sx, m2 / sy, m3 / sy, m4, m5]);
+                true
+            }
+            LiveShape::Ellipse { xf, .. } | LiveShape::Polygon { xf, .. } => {
+                *xf = a * *xf;
+                false
+            }
             LiveShape::Line { a: p, b } => {
                 *p = a * *p;
                 *b = a * *b;
+                false
             }
         }
     }
@@ -613,11 +649,10 @@ impl Node {
             NodeKind::Path { path, live, .. } => {
                 path.transform(a);
                 if let Some(l) = live {
-                    l.transform(a);
-                    if sc.keep_corners
-                        && let Some(k) = k
-                        && l.keep_corners(k)
-                    {
+                    // A rectangle scaled unevenly keeps circular corners: its path is regenerated.
+                    let reshaped = l.transform(a);
+                    let kept = sc.keep_corners && k.is_some_and(|k| l.keep_corners(k));
+                    if reshaped || kept {
                         *path = l.to_path();
                     }
                 }
@@ -1135,6 +1170,113 @@ mod tests {
         assert_eq!(l.label(), "Rectangle");
     }
 
+    /// A node holding a live rectangle (`w` × `h`, all radii `r`, placed by `xf`) and its path.
+    fn live_rect(w: f64, h: f64, r: f64, xf: Affine) -> Node {
+        let live = LiveShape::Rectangle { w, h, radii: [r; 4], xf };
+        let mut n = Node::path(NodeId(1), live.to_path(), Appearance::default_art());
+        if let NodeKind::Path { live: slot, .. } = &mut n.kind {
+            *slot = Some(live);
+        }
+        n
+    }
+
+    fn live_of(n: &Node) -> (f64, f64, [f64; 4], Affine) {
+        let NodeKind::Path { live: Some(LiveShape::Rectangle { w, h, radii, xf }), .. } = &n.kind else { panic!("not a live rectangle") };
+        (*w, *h, *radii, *xf)
+    }
+
+    fn near(a: f64, b: f64) -> bool {
+        (a - b).abs() < 1e-9
+    }
+
+    fn near_xf(a: Affine, b: Affine) -> bool {
+        a.as_coeffs().iter().zip(b.as_coeffs()).all(|(x, y)| near(*x, y))
+    }
+
+    /// Size and radius of a live rectangle, within rounding.
+    fn assert_live(n: &Node, w: f64, h: f64, r: f64) {
+        let (lw, lh, radii, _) = live_of(n);
+        assert!(near(lw, w) && near(lh, h) && radii.iter().all(|x| near(*x, r)), "{lw} × {lh} r {radii:?}, want {w} × {h} r {r}");
+    }
+
+    /// Each corner arc of a rounded rectangle's path, mapped by `back` (to undo a rotation),
+    /// spans `r` along x and y: the corner is a circular arc of radius `r`.
+    fn assert_round_corners(n: &Node, back: Affine, r: f64) {
+        let NodeKind::Path { path, .. } = &n.kind else { panic!("not a path") };
+        let a: Vec<Point> = path.subpaths[0].anchors.iter().map(|a| back * a.p).collect();
+        assert_eq!(a.len(), 8, "a rounded rectangle");
+        // Anchors 1→2, 3→4, 5→6 and 7→0 are the arcs.
+        for (i, j) in [(1, 2), (3, 4), (5, 6), (7, 0)] {
+            let (x, y) = ((a[j].x - a[i].x).abs(), (a[j].y - a[i].y).abs());
+            assert!(near(x, r) && near(y, r), "corner spans {x} × {y}, want {r} × {r}");
+        }
+    }
+
+    const KEEP_CORNERS: Scaling = Scaling { strokes: false, effects: None, keep_type_strokes: false, keep_corners: true };
+
+    #[test]
+    fn uneven_scales_keep_live_corners_circular() {
+        // A 100 pt rounded square at (10, 10) stretched to 300 × 100 (#291).
+        let mut n = live_rect(100.0, 100.0, 20.0, Affine::translate((10.0, 10.0)));
+        let stretch = Affine::translate((10.0, 10.0)) * Affine::scale_non_uniform(3.0, 1.0) * Affine::translate((-10.0, -10.0));
+        n.transform(stretch, KEEP_CORNERS);
+        assert_live(&n, 300.0, 100.0, 20.0);
+        assert!(near_xf(live_of(&n).3, Affine::translate((10.0, 10.0))), "the scale went into the size");
+        let b = n.geometric_bounds().unwrap();
+        assert!(near(b.x0, 10.0) && near(b.y0, 10.0) && near(b.x1, 310.0) && near(b.y1, 110.0), "{b:?}");
+        assert_round_corners(&n, Affine::IDENTITY, 20.0);
+        // Scale Corners on: the radius scales by the mean scale, still circular.
+        let mut n = live_rect(100.0, 100.0, 20.0, Affine::IDENTITY);
+        n.transform(Affine::scale_non_uniform(4.0, 1.0), Scaling::default());
+        assert_live(&n, 400.0, 100.0, 40.0);
+        assert_round_corners(&n, Affine::IDENTITY, 40.0);
+        // Squashed below the radius, the short sides are fully round; stretched back, it returns.
+        n.transform(Affine::scale_non_uniform(1.0, 0.5), KEEP_CORNERS);
+        assert_round_corners(&n, Affine::IDENTITY, 25.0);
+        n.transform(Affine::scale_non_uniform(1.0, 2.0), KEEP_CORNERS);
+        assert_round_corners(&n, Affine::IDENTITY, 40.0);
+    }
+
+    #[test]
+    fn rotated_and_reflected_live_rectangles_scale_along_their_own_sides() {
+        let place = Affine::translate((200.0, 100.0)) * Affine::rotate(30f64.to_radians());
+        let mut n = live_rect(100.0, 50.0, 10.0, place);
+        // Stretched along its own width, as a bounding-box drag of a rotated shape does.
+        n.transform(place * Affine::scale_non_uniform(2.0, 1.0) * place.inverse(), KEEP_CORNERS);
+        assert_live(&n, 200.0, 50.0, 10.0);
+        assert!(near_xf(live_of(&n).3, place));
+        assert_round_corners(&n, place.inverse(), 10.0);
+        // A reflection stays in `xf`; the corners stay as they were.
+        n.transform(Affine::scale_non_uniform(-1.0, 1.0), KEEP_CORNERS);
+        assert_live(&n, 200.0, 50.0, 10.0);
+        let xf = live_of(&n).3;
+        assert!(near(xf.determinant(), -1.0));
+        assert_round_corners(&n, xf.inverse(), 10.0);
+    }
+
+    #[test]
+    fn shears_and_moves_keep_the_old_transform() {
+        // Scaling a rotated rectangle along the page axes shears it: `xf` takes it all, as before.
+        let rot = Affine::rotate(30f64.to_radians());
+        let mut n = live_rect(100.0, 50.0, 10.0, rot);
+        let before = n.clone();
+        let a = Affine::scale_non_uniform(2.0, 1.0);
+        n.transform(a, Scaling::default());
+        assert_eq!(live_of(&n), (100.0, 50.0, [10.0; 4], a * rot));
+        let (NodeKind::Path { path, .. }, NodeKind::Path { path: old, .. }) = (&n.kind, &before.kind) else { panic!() };
+        assert_eq!(*path, old.transformed(a));
+        // A file saved with an uneven scale in `xf` keeps its exact geometry when moved...
+        let legacy = Affine::translate((5.0, 5.0)) * Affine::scale_non_uniform(2.0, 1.0);
+        let mut n = live_rect(100.0, 100.0, 20.0, legacy);
+        n.transform(Affine::translate((10.0, 0.0)), KEEP_CORNERS);
+        assert_eq!(live_of(&n), (100.0, 100.0, [20.0; 4], Affine::translate((10.0, 0.0)) * legacy));
+        // ...and once scaled, has document units and circular corners of its mean radius.
+        n.transform(Affine::scale(2.0), Scaling::default());
+        assert_live(&n, 400.0, 200.0, 20.0 * 2f64.sqrt() * 2.0);
+        assert!(near(live_of(&n).3.determinant(), 1.0));
+        assert_round_corners(&n, Affine::IDENTITY, 20.0 * 2f64.sqrt() * 2.0);
+    }
+
     #[test]
     fn default_transparency() {
         let p = || Node::path(NodeId(1), shapes::rectangle(Rect::new(0.0, 0.0, 10.0, 10.0)), Appearance::default_art());

crates/doc/src/text.rs

@@ -2,7 +2,7 @@
 
 use serde::{Deserialize, Serialize};
 use vectorcraft_color::{Color, Paint};
-use vectorcraft_geom::{Affine, PathData, Point, Rect};
+use vectorcraft_geom::{Affine, PathData, Point, Rect, Vec2};
 
 use crate::appearance::{Appearance, AppearanceItem, Dash, FillLayer, LineCap, LineJoin, StrokeLayer};
 
@@ -414,6 +414,9 @@ pub enum TextKind {
 /// A text object. `runs` split into paragraphs at `\n`.
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 pub struct TextObject {
+    /// Top-to-bottom, right-to-left writing. Defaults to horizontal for old documents.
+    #[serde(default, skip_serializing_if = "crate::skip::is_default")]
+    pub vertical: bool,
     pub kind: TextKind,
     /// Maps text space (origin = first baseline start for point type) to the document.
     pub xf: Affine,
@@ -437,6 +440,7 @@ pub struct TextObject {
 impl TextObject {
     pub fn point(origin: Point, text: &str, style: CharStyle) -> Self {
         Self {
+            vertical: false,
             kind: TextKind::Point,
             xf: Affine::translate(origin.to_vec2()),
             runs: vec![TextRun { text: text.into(), style }],
@@ -472,6 +476,49 @@ impl TextObject {
     pub fn transform(&mut self, a: Affine) {
         self.xf = a * self.xf;
     }
+    /// Area type's frame (the type area) in document space; None for other type.
+    pub fn area_frame(&self) -> Option<PathData> {
+        match &self.kind {
+            TextKind::Area { frame } => Some(frame.transformed(self.xf)),
+            _ => None,
+        }
+    }
+    /// Reshape area type's frame by `a`, a document-space transform, keeping the type at its size
+    /// (a bounding-box resize: the text reflows, it isn't scaled). False, changing nothing, for
+    /// other type, a degenerate `xf` or a frame that would not be finite.
+    pub fn transform_area(&mut self, a: Affine) -> bool {
+        let xf = self.xf;
+        self.reshape_area(|frame, to_text| {
+            frame.transform(to_text * a * xf);
+            true
+        })
+    }
+    /// Move anchors `refs` (subpath, anchor) of area type's frame by `d` in document space, with
+    /// their handles (a Direct Selection drag of a frame corner or edge). False, changing
+    /// nothing, when an anchor doesn't exist, or as [`Self::transform_area`].
+    pub fn move_area_anchors(&mut self, refs: &[(usize, usize)], d: Vec2) -> bool {
+        self.reshape_area(|frame, to_text| {
+            // A distance: only the linear part of the document → text map applies.
+            let local = to_text * d.to_point() - to_text * Point::ZERO;
+            refs.iter().all(|&(si, ai)| frame.anchor_mut(si, ai).map(|a| a.translate(local)).is_some())
+        })
+    }
+    /// Edit a copy of the area frame with `f` (given the document → text space map) and keep it
+    /// when `f` succeeds and the result is finite.
+    fn reshape_area(&mut self, f: impl FnOnce(&mut PathData, Affine) -> bool) -> bool {
+        let det = self.xf.determinant();
+        if !det.is_finite() || det.abs() < 1e-12 {
+            return false;
+        }
+        let to_text = self.xf.inverse();
+        let TextKind::Area { frame } = &mut self.kind else { return false };
+        let mut next = frame.clone();
+        if !f(&mut next, to_text) || !next.anchors().all(|(_, _, a)| a.p.is_finite() && a.h_in.is_finite() && a.h_out.is_finite()) {
+            return false;
+        }
+        *frame = next;
+        true
+    }
     /// Scale the character strokes' weights and dashes by `s` (they are drawn in text space, so
     /// `1 / scale` keeps their weight through a transform that scales the type).
     pub fn scale_char_strokes(&mut self, s: f64) {
@@ -501,4 +548,49 @@ mod tests {
         assert!(b.x0 >= 10.0 - 1e-9 && b.y1 > 20.0);
         assert_eq!(CharStyle::default().effective_leading(), 14.399999999999999);
     }
+
+    /// 120 × 40 area type at (40, 40), its text drawn at twice its size.
+    fn area_type() -> TextObject {
+        let mut t = TextObject::point(Point::ZERO, "Some text", CharStyle::default());
+        t.kind = TextKind::Area { frame: vectorcraft_geom::shapes::rectangle(Rect::new(0.0, 0.0, 60.0, 20.0)) };
+        t.xf = Affine::translate((40.0, 40.0)) * Affine::scale(2.0);
+        t
+    }
+
+    #[test]
+    fn area_resizes_its_frame_and_keeps_its_type() {
+        let mut t = area_type();
+        assert_eq!(t.bounds(), Some(Rect::new(40.0, 40.0, 160.0, 80.0)));
+        // Bottom-right handle to (200, 140), about the top-left corner.
+        let o = Affine::translate((40.0, 40.0));
+        assert!(t.transform_area(o * Affine::scale_non_uniform(160.0 / 120.0, 100.0 / 40.0) * o.inverse()));
+        assert_eq!(t.xf, Affine::translate((40.0, 40.0)) * Affine::scale(2.0), "the type keeps its size");
+        let b = t.bounds().unwrap();
+        assert!((b.x1 - 200.0).abs() < 1e-9 && (b.y1 - 140.0).abs() < 1e-9 && b.x0 == 40.0, "{b:?}");
+        assert_eq!(t.area_frame().unwrap().bounds(), Some(b));
+        // Point type has no area; a degenerate transform or a non-finite frame changes nothing.
+        let mut p = TextObject::point(Point::ZERO, "x", CharStyle::default());
+        assert!(!p.transform_area(Affine::scale(2.0)) && p.area_frame().is_none());
+        let before = t.clone();
+        assert!(!t.transform_area(Affine::scale(f64::INFINITY)));
+        t.xf = Affine::scale(0.0);
+        assert!(!t.transform_area(Affine::scale(2.0)));
+        t.xf = before.xf;
+        assert_eq!(t, before);
+    }
+
+    #[test]
+    fn area_anchors_move_in_document_space() {
+        let mut t = area_type();
+        // The bottom-right corner (anchor 2) 20 pt right: 10 pt in text space at 2×.
+        assert!(t.move_area_anchors(&[(0, 2)], Vec2::new(20.0, 0.0)));
+        let TextKind::Area { frame } = &t.kind else { panic!() };
+        assert_eq!(frame.subpaths[0].anchors[2].p, Point::new(70.0, 20.0));
+        assert_eq!(frame.subpaths[0].anchors[1].p, Point::new(60.0, 0.0), "the others stay");
+        // A missing anchor changes nothing.
+        let before = t.clone();
+        assert!(!t.move_area_anchors(&[(0, 1), (0, 9)], Vec2::new(5.0, 5.0)));
+        assert!(!t.move_area_anchors(&[(3, 0)], Vec2::new(5.0, 5.0)));
+        assert_eq!(t, before);
+    }
 }

crates/engine/src/cmd/buildcmds.rs

@@ -16,7 +16,7 @@ use serde_json::{Value, json};
 use vectorcraft_color::{Color, Paint};
 use vectorcraft_doc::appearance::{AppearanceItem, FillLayer, StrokeLayer};
 use vectorcraft_doc::{Appearance, Document, Node, NodeId, NodeKind, Selection};
-use vectorcraft_geom::{FillRule, PathData, Point, Rect, Shape as _};
+use vectorcraft_geom::{FillRule, Point, Rect, Shape as _};
 use vectorcraft_pathops as po;
 use vectorcraft_tools::builder::{
     self as b, EDGE_NAME, FACE_NAME, LIVE_PAINT_NAME, SOURCES_NAME, edge_near, face_at, is_live_paint, sample_polyline, shapes_for, sorted_roots,
@@ -205,52 +205,6 @@ fn stroke_only(paint: Paint, width: f64) -> Appearance {
     Appearance { items: vec![AppearanceItem::Stroke(StrokeLayer::new(paint, width))], ..Default::default() }
 }
 
-/// A point strictly inside a filled path (for re-finding faces after a rebuild).
-pub(crate) fn interior_point(path: &PathData) -> Option<Point> {
-    let bb = path.bounds()?;
-    let bp = path.to_bezpath();
-    let mut edges: Vec<(Point, Point)> = vec![];
-    let (mut first, mut last) = (Point::ZERO, Point::ZERO);
-    kurbo::flatten(bp.iter(), (bb.width().max(bb.height()) * 1e-3).max(1e-4), |el| match el {
-        kurbo::PathEl::MoveTo(p) => {
-            if last != first {
-                edges.push((last, first));
-            }
-            first = p;
-            last = p;
-        }
-        kurbo::PathEl::LineTo(p) => {
-            edges.push((last, p));
-            last = p;
-        }
-        kurbo::PathEl::ClosePath => {
-            if last != first {
-                edges.push((last, first));
-            }
-            last = first;
-        }
-        _ => {}
-    });
-    if last != first {
-        edges.push((last, first));
-    }
-    let mut best: Option<(f64, Point)> = None;
-    for f in [0.5, 0.25, 0.75, 0.125, 0.375, 0.625, 0.875, 0.0625, 0.9375] {
-        let y = bb.y0 + bb.height() * f;
-        let mut xs: Vec<f64> =
-            edges.iter().filter(|(a, c)| (a.y <= y) != (c.y <= y)).map(|(a, c)| a.x + (y - a.y) / (c.y - a.y) * (c.x - a.x)).collect();
-        xs.sort_by(f64::total_cmp);
-        for w in xs.windows(2) {
-            let m = Point::new((w[0] + w[1]) / 2.0, y);
-            let width = w[1] - w[0];
-            if width > best.map_or(0.0, |b| b.0) && bp.winding(m) != 0 {
-                best = Some((width, m));
-            }
-        }
-    }
-    best.map(|b| b.1)
-}
-
 // ---------- Shape Builder ----------
 
 fn fill_param(s: &Session, p: &Value, cmd: &str) -> Result<Option<Paint>> {
@@ -395,7 +349,11 @@ fn build_children(d: &mut Document, sources: Vec<Arc<Node>>) -> Result<(Vec<Arc<
     src_group.name = Some(SOURCES_NAME.into());
     src_group.visible = false;
     children.push(Arc::new(src_group));
-    let regs = po::regions(&shapes);
+    // Every path is an edge, open ones included; faces are the areas they enclose.
+    let (regs, edges) = po::live_paint(&shapes);
+    if regs.is_empty() && edges.is_empty() {
+        return Err(EngineError::Other("Live Paint: these paths are too degenerate to paint".into()));
+    }
     let nfaces = regs.len();
     for r in regs {
         let id = d.alloc_id();
@@ -404,10 +362,9 @@ fn build_children(d: &mut Document, sources: Vec<Arc<Node>>) -> Result<(Vec<Arc<
         n.name = Some(FACE_NAME.into());
         children.push(Arc::new(n));
     }
-    let edges = po::pathfinder(po::PathfinderOp::Outline, &shapes);
     let nedges = edges.len();
     for e in edges {
-        let (_, stroke, w) = &styles[e.key as usize];
+        let Some((_, stroke, w)) = styles.get(e.key as usize) else { continue };
         let id = d.alloc_id();
         let mut n = Node::path(id, e.path, stroke_only(stroke.clone(), *w));
         n.name = Some(EDGE_NAME.into());
@@ -451,7 +408,7 @@ fn lp_merge(s: &mut Session, p: &Value) -> Result<Value> {
         let keep_faces: Vec<(Point, Paint)> = b::faces(&old)
             .iter()
             .filter(|f| !f.appearance.fill_paint().is_none())
-            .filter_map(|f| Some((interior_point(f.path_data()?)?, f.appearance.fill_paint())))
+            .filter_map(|f| Some((po::interior_point(f.path_data()?)?, f.appearance.fill_paint())))
             .collect();
         let keep_edges: Vec<(Point, Appearance)> = b::edges(&old)
             .iter()

crates/engine/src/cmd/create.rs

@@ -50,7 +50,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Create Text",
             [],
             None,
-            "{x, y, text, size?: pt, font?: family, style?, color?, area?: {width, height}} → {id}",
+            "{x, y, text, vertical?: bool = false, size?: pt, font?: family, style?, color?, area?: {width, height}} → {id}",
             has_doc,
             text_create
         ),
@@ -401,6 +401,7 @@ fn text_create(s: &mut Session, p: &Value) -> Result<Value> {
     let y = f64_req(p, "y", "text.create")?;
     let text = str_param(p, "text").unwrap_or("");
     let mut t = TextObject::point(Point::new(x, y), text, new_type_style(s, p));
+    t.vertical = p.get("vertical").and_then(Value::as_bool).unwrap_or(false);
     if let Some(a) = p.get("area") {
         let w = f64_or(a, "width", 200.0);
         let h = f64_or(a, "height", 100.0);

crates/engine/src/cmd/edit.rs

@@ -116,10 +116,21 @@ fn set_units(s: &mut Session, p: &Value) -> Result<Value> {
     ok()
 }
 
+/// A typing session in progress (the Type tool previews the whole session as one interaction).
+fn typing_in_progress(s: &Session) -> bool {
+    s.active().and_then(|d| d.interaction.as_ref()).is_some_and(|it| it.label == "Typing" && it.preview.is_some())
+}
+
 fn undo(s: &mut Session, _: &Value) -> Result<Value> {
     // What is still in progress (typing, a drag) is the step to undo: keep it first, so Undo takes
     // back only that and Redo brings it back, instead of dropping it and undoing the step before.
+    // A typing session also ends in the Type tool, whose caret and marked text (IME) must follow
+    // the document.
+    let typing = typing_in_progress(s);
     s.commit_interaction()?;
+    if typing {
+        s.set_tool_option("endTyping", &Value::Bool(true));
+    }
     let st = s.doc_mut()?;
     let e = st.history.undo.pop().ok_or_else(|| EngineError::Other("nothing to undo".into()))?;
     let label = e.label.clone();

crates/engine/src/cmd/effectcmd.rs

@@ -23,7 +23,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Apply Effect",
             [],
             None,
-            "{effect: id (see effect.list, e.g. \"stylize.dropShadow\", \"distort.roughen\", \"warp.arc\", or \"plugin.<id>\" for an installed effect plug-in), params?: {…} (missing keys take the dialog defaults), item?: appearance item index|null (apply to that fill/stroke only; omitted: the Appearance panel's active item, else the whole object), ids?: [..] (layers too), target?: \"object\"|\"contents\" (contents: the objects inside groups and layers)} append a live effect to each selected object's appearance (a group's or layer's apply to its members as one piece: one combined shadow) → {ids, index, item}",
+            "{effect: id (see effect.list, e.g. \"stylize.dropShadow\", \"distort.roughen\", \"warp.arc\", or \"plugin.<id>\" for an installed effect plug-in), params?: {…} (missing keys take the dialog defaults), item?: appearance item index|null (apply to that fill/stroke only; omitted: the Appearance panel's active item, else the whole object), ids?: [..] (layers too), target?: \"object\"|\"contents\" (contents: the objects inside groups and layers)} append a live effect to each selected object's appearance (a group's or layer's apply to its members as one piece: one combined shadow; a Pathfinder effect, which combines a group's contents, groups several loose selected objects first, in the same undo step) → {ids, index, item, grouped?}",
             has_doc,
             apply
         ),
@@ -130,6 +130,15 @@ pub(crate) fn apply(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let effect = effects::new_effect(id, &params).ok_or_else(|| bad(C, format!("unknown effect `{id}`")))?;
     let label = effects::effect_info(id).map(|e| e.label.trim_end_matches('…').to_string()).unwrap_or_default();
+    if let Some(loose) = loose_for_pathfinder(s, p, id)? {
+        let gid = s.edit(&label, |d, sel| {
+            let gid = super::object::group_nodes(d, &loose)?;
+            d.node_mut(gid).ok_or(EngineError::NoNode(gid))?.appearance.effects.push(effect.clone());
+            sel.set([gid]);
+            Ok(gid)
+        })?;
+        return Ok(json!({ "ids": [gid.0], "index": 0, "item": null, "grouped": true }));
+    }
     let item = item_target(s, p, C)?;
     let mut index = 0;
     let ids = edit_effects(s, p, item, C, &label, "Apply Effect: select objects", |fx| {
@@ -143,6 +152,19 @@ pub(crate) fn apply(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({ "ids": ids_json(&ids), "index": index, "item": landed }))
 }
 
+/// The selected objects a Pathfinder effect should group before it applies: it combines the
+/// contents of a group or layer, so on several loose objects (none a group) it would do nothing.
+/// `None` when the effect isn't one, objects are named (`ids`) or another target is asked for.
+fn loose_for_pathfinder(s: &Session, p: &Value, id: &str) -> Result<Option<Vec<NodeId>>> {
+    if !effects::is_pathfinder(id) || ["ids", "id", "item", "target"].iter().any(|k| p.get(k).is_some()) {
+        return Ok(None);
+    }
+    let roots = super::appearance::subject_roots(s)?;
+    let d = &s.doc()?.doc;
+    let grouped = roots.iter().any(|r| d.node(*r).is_some_and(|n| matches!(n.kind, NodeKind::Group { clip: false, .. } | NodeKind::Layer { .. })));
+    Ok((roots.len() >= 2 && !grouped).then_some(roots))
+}
+
 fn list(s: &mut Session, p: &Value) -> Result<Value> {
     let catalog: Vec<Value> = effects::effect_catalog()
         .into_iter()
@@ -507,6 +529,34 @@ mod tests {
         assert!((b.x1 - 320.0).abs() < 1e-6, "{b:?}");
     }
 
+    #[test]
+    fn pathfinder_effect_on_loose_objects_groups_them_first() {
+        let (mut s, a) = session_with_rect();
+        let b = NodeId(s.execute("shape.rectangle", &json!({"x": 150, "y": 100, "width": 100, "height": 100})).unwrap()["id"].as_u64().unwrap());
+        s.execute("select.set", &json!({"ids": [a.0, b.0]})).unwrap();
+        let r = s.execute("effect.apply", &json!({"effect": "pathfinder.add"})).unwrap();
+        assert_eq!(r["grouped"], true);
+        let g = NodeId(r["ids"][0].as_u64().unwrap());
+        let gn = node(&s, g);
+        assert_eq!(gn.children().unwrap().iter().map(|c| c.id).collect::<Vec<_>>(), [a, b], "stacking order kept");
+        assert!(vectorcraft_render::effects::has_pathfinder(&gn));
+        assert_eq!(s.doc().unwrap().selection.objects, [g]);
+        // Live: one united shape, so expanding leaves a single path.
+        s.execute("effect.expandAppearance", &json!({})).unwrap();
+        assert_eq!(node(&s, g).children().unwrap().len(), 1);
+        // Grouping and applying are one undo step.
+        s.execute("edit.undo", &json!({})).unwrap();
+        s.execute("edit.undo", &json!({})).unwrap();
+        let d = &s.doc().unwrap().doc;
+        assert!(d.node(g).is_none());
+        assert!(d.node(a).is_some_and(|n| n.appearance.effects.is_empty()) && d.parent_of(a) == d.parent_of(b));
+        // A selection holding a group applies to each object as before; so does a single object.
+        s.execute("select.set", &json!({"ids": [a.0]})).unwrap();
+        let r = s.execute("effect.apply", &json!({"effect": "pathfinder.add"})).unwrap();
+        assert!(r.get("grouped").is_none());
+        assert_eq!(node(&s, a).appearance.effects.len(), 1);
+    }
+
     #[test]
     fn pathfinder_effect_on_a_group_renders_live_and_expands() {
         let (mut s, a) = session_with_rect();

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

@@ -11,7 +11,7 @@ use crate::DocState;
 
 use super::super::*;
 use super::encode::single_artboard;
-use super::{ARTBOARD_PARAMS, Format, default_name, encode, encode_all, merge, writable, write_encoded, write_or_return};
+use super::{ARTBOARD_PARAMS, Format, default_name, encode, encode_all, encode_with_warnings, merge, writable, write_encoded, write_or_return};
 
 pub(super) fn serialize(s: &mut Session, p: &Value) -> Result<Value> {
     let f = writable("document.serialize", Some(str_param(p, "format").unwrap_or("vectorcraft")), None)?;
@@ -151,8 +151,10 @@ pub(super) fn export_selection(s: &mut Session, p: &Value) -> Result<Value> {
     let expanded = expand_presets(s, C, p)?;
     let p = &*expanded;
     let (d, bounds) = selection(s, C)?;
-    let bytes = encode(&d, f.id, &without_artboards(p))?;
-    write_or_return(path, &bytes, json!({ "bounds": [bounds.x0, bounds.y0, bounds.width(), bounds.height()] }))
+    // The encoder's warnings (options accepted but not applied, features approximated or left
+    // out), as document.export reports them.
+    let (bytes, warnings) = encode_with_warnings(&d, f.id, &without_artboards(p))?;
+    write_or_return(path, &bytes, json!({ "format": f.id, "warnings": warnings, "bounds": [bounds.x0, bounds.y0, bounds.width(), bounds.height()] }))
 }
 
 /// File → Save for Office Documents: one artboard as a PNG at `ppi`, on white unless

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

@@ -105,7 +105,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Export Selection…",
             ["File"],
             None,
-            "{path?, format?: png|jpg|webp|svg|svgz|pdf (default: from the extension, else png), scale?: 1, …the format's options} the selected objects cropped to their bounds (template layers left out) → {path, bytes, bounds} (no path → {dataBase64, bounds})",
+            "{path?, format?: png|jpg|webp|svg|svgz|pdf (default: from the extension, else png), scale?: 1, …the format's options} the selected objects cropped to their bounds (template layers left out) → {path, format, bytes, warnings, bounds} (no path → {dataBase64, format, bytes, warnings, bounds}); warnings say what the format approximated or left out, as for document.export",
             has_selection,
             export::export_selection
         ),
@@ -581,6 +581,18 @@ pub const OPEN_EXTS: &[&str] = &[
     "eps",
 ];
 
+/// The extension that picks each writable format when exporting (the format's first; PNG-8 shares
+/// `.png` with PNG, so `.png` comes once), in [`FORMATS`] order.
+pub fn export_extensions() -> Vec<&'static str> {
+    let mut v: Vec<&'static str> = Vec::new();
+    for e in FORMATS.iter().filter(|f| f.write).filter_map(|f| f.extensions.first()) {
+        if !v.contains(e) {
+            v.push(e);
+        }
+    }
+    v
+}
+
 /// Text files: File → Place sets them as area type (Text Import Options).
 pub const TEXT_EXTS: &[&str] = &["txt"];
 

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

@@ -150,6 +150,39 @@ fn open_exts_cover_every_readable_format() {
     assert_eq!(filters.last(), Some(&("Plug-ins", crate::cmd::plugin::EXTS)), "File › Open installs plug-ins");
 }
 
+/// The extensions usage texts list for export: one per writable format, each picking that format
+/// (`.png` picks PNG; PNG-8 is asked for by `format`).
+#[test]
+fn export_extensions_name_every_writable_format() {
+    let exts = export_extensions();
+    assert_eq!(
+        exts,
+        [
+            "vectorcraft",
+            "svg",
+            "svgz",
+            "pdf",
+            "png",
+            "jpg",
+            "gif",
+            "webp",
+            "tif",
+            "bmp",
+            "vctemplate",
+            "txt",
+            "dxf",
+            "eps",
+            "emf",
+            "wmf",
+            "tga",
+            "psd"
+        ]
+    );
+    for e in exts {
+        assert!(format_for_name(&format!("x.{e}")).is_some_and(|f| f.write), "{e}");
+    }
+}
+
 #[test]
 fn formats_query_lists_readers_writers_and_options() {
     let mut s = Session::new();

crates/engine/src/cmd/fonts.rs

@@ -17,7 +17,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Fonts in Document",
             [],
             None,
-            "{selectionOnly?} → [{family, style, runs, objects, missing}] sorted by name",
+            "{selectionOnly?} → [{family, style, runs, objects, missing, status: exact|substitute|missing, resolved: {family, style}, missingGlyphs}] sorted by name. A font is found by any of its names (ヒラギノ角ゴシック = Hiragino Sans) among the loaded and installed fonts; substitute: the family is there but not the style (resolved names the stand-in); missing: the family is unknown (the fallback family stands in); missingGlyphs: characters of its text the resolved font lacks (drawn by a fallback font)",
             has_doc,
             fonts
         ),
@@ -26,7 +26,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Replace Font",
             [],
             None,
-            "{from: {family, style?}, to: {family, style?}, selectionOnly?} (style omitted: every style of the family / keep the closest style) → {runs}",
+            "{from: {family, style?}, to: {family (any of its names; stored as the font's own family name), style?}, selectionOnly?} (style omitted: every style of the family / keep the closest style) → {runs}",
             has_doc,
             replace
         ),
@@ -44,7 +44,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Font List",
             [],
             None,
-            "{family?} → {families: [names]} sorted: the bundled fonts, fonts added and the fonts installed on the system (none on the web); with family: {family, styles: [names]} (upright styles by weight, then italics; an error when the family isn't available)",
+            "{family?} → {families: [names]} sorted: the bundled fonts, fonts added and the fonts installed on the system (none on the web), as the font menus list them (without the system's hidden families, whose names start with a dot; they still resolve by name); with family: {family, styles: [names]} (upright styles by weight, then italics; an error when the family isn't available)",
             always,
             font_list
         ),
@@ -53,7 +53,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Refresh Font List",
             [],
             None,
-            "{} scan the system font folders again, for fonts installed or removed since the app started; text in a font that became available redraws in it (no fonts are installed on the web) → {families, faces} (families available, installed faces found)",
+            "{} scan the system font folders again, for fonts installed or removed since the app started; text in a font that became available redraws in it (no fonts are installed on the web) → {families, faces} (families listed, installed faces found)",
             always,
             rescan
         ),
@@ -96,12 +96,12 @@ fn fonts(s: &mut Session, p: &Value) -> Result<Value> {
     let ids = scope(s, bool_or(p, "selectionOnly", false))?;
     let d = &s.doc()?.doc;
     let db = vectorcraft_text::FontDb::global();
-    let families = db.families();
-    let mut found: BTreeMap<(String, String), (usize, Vec<NodeId>)> = BTreeMap::new();
+    let mut found: BTreeMap<(String, String), (usize, Vec<NodeId>, String)> = BTreeMap::new();
     for id in ids {
         for r in text(d, id).map(|t| t.runs.as_slice()).unwrap_or_default() {
             let e = found.entry((r.style.font_family.clone(), r.style.font_style.clone())).or_default();
             e.0 += 1;
+            e.2.push_str(&r.text);
             if !e.1.contains(&id) {
                 e.1.push(id);
             }
@@ -109,10 +109,20 @@ fn fonts(s: &mut Session, p: &Value) -> Result<Value> {
     }
     let list: Vec<Value> = found
         .into_iter()
-        .map(|((family, style), (runs, objects))| {
-            let have_family = families.iter().any(|f| f.eq_ignore_ascii_case(&family));
-            let missing = !have_family || !db.styles(&family).iter().any(|st| st.eq_ignore_ascii_case(&style));
-            json!({ "family": family, "style": style, "runs": runs, "objects": objects.len(), "missing": missing })
+        .map(|((family, style), (runs, objects, chars))| {
+            let resolved = db.resolve(&family, &style);
+            let status = resolved.as_ref().map(|(_, m)| *m).unwrap_or(vectorcraft_text::FontMatch::Missing);
+            let mut lacking: Vec<char> = chars.chars().filter(|c| !c.is_whitespace() && !c.is_control()).collect();
+            lacking.sort_unstable();
+            lacking.dedup();
+            lacking.retain(|c| !resolved.as_ref().is_some_and(|(f, _)| f.covers(*c)));
+            json!({
+                "family": family, "style": style, "runs": runs, "objects": objects.len(),
+                "missing": status == vectorcraft_text::FontMatch::Missing,
+                "status": status.as_str(),
+                "resolved": resolved.as_ref().map(|(f, _)| json!({ "family": f.family, "style": f.style })),
+                "missingGlyphs": lacking.len(),
+            })
         })
         .collect();
     Ok(json!(list))
@@ -130,9 +140,11 @@ fn replace(s: &mut Session, p: &Value) -> Result<Value> {
     let (ff, fs) = font_param(p, "from", C)?;
     let (tf, ts) = font_param(p, "to", C)?;
     let db = vectorcraft_text::FontDb::global();
-    if !db.families().iter().any(|f| f.eq_ignore_ascii_case(&tf)) {
-        return Err(bad(C, format!("font family `{tf}` is not available")));
-    }
+    // Any name of the family (ヒラギノ角ゴシック) is stored as its own name (Hiragino Sans).
+    let tf = match db.resolve(&tf, ts.as_deref().unwrap_or("Regular")) {
+        Some((f, m)) if m != vectorcraft_text::FontMatch::Missing => f.family.clone(),
+        _ => return Err(bad(C, format!("font family `{tf}` is not available"))),
+    };
     let ids = scope(s, bool_or(p, "selectionOnly", false))?;
     let matches = |st: &vectorcraft_doc::CharStyle| {
         st.font_family.eq_ignore_ascii_case(&ff) && fs.as_ref().is_none_or(|x| st.font_style.eq_ignore_ascii_case(x))
@@ -196,7 +208,7 @@ fn font_list(_: &mut Session, p: &Value) -> Result<Value> {
             let name = db.family_list().iter().find(|f| f.eq_ignore_ascii_case(family)).cloned().unwrap_or_else(|| family.to_string());
             Ok(json!({ "family": name, "styles": db.styles(family) }))
         }
-        None => Ok(json!({ "families": *db.family_list() })),
+        None => Ok(json!({ "families": *db.menu_family_list() })),
     }
 }
 
@@ -229,7 +241,7 @@ fn rescan(s: &mut Session, _: &Value) -> Result<Value> {
         }
         d.revision += 1;
     }
-    Ok(json!({ "families": db.family_list().len(), "faces": faces }))
+    Ok(json!({ "families": db.menu_family_list().len(), "faces": faces }))
 }
 
 #[cfg(test)]
@@ -261,6 +273,41 @@ mod tests {
 mod open_tests {
     use super::*;
 
+    #[test]
+    fn list_says_how_each_font_resolved() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 200, "height": 200})).unwrap();
+        // "Black Wide" is a style no Source Sans 3 has, bundled or installed, so it is always a
+        // substitute (the installed family can hold a real Black).
+        for (text, font, style) in
+            [("Exact", "Source Sans 3", "Semibold"), ("Closest", "Source Sans 3", "Black Wide"), ("Gone", "No Such Font Family", "Regular")]
+        {
+            s.execute("text.create", &json!({"x": 10, "y": 20, "text": text, "font": font, "style": style})).unwrap();
+        }
+        let list = s.execute("text.fonts", &json!({})).unwrap();
+        let rows: Vec<(String, String, String, String)> = list
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|f| {
+                (
+                    f["style"].as_str().unwrap().into(),
+                    f["status"].as_str().unwrap().into(),
+                    f["resolved"]["family"].as_str().unwrap().into(),
+                    f["resolved"]["style"].as_str().unwrap().into(),
+                )
+            })
+            .collect();
+        let row = |style: &str| rows.iter().find(|r| r.0 == style).cloned().unwrap();
+        assert_eq!(row("Semibold").1, "exact");
+        assert_eq!(row("Black Wide").1, "substitute", "{rows:?}");
+        assert_eq!(row("Black Wide").2, "Source Sans 3");
+        assert_eq!((row("Regular").1.as_str(), row("Regular").2.as_str()), ("missing", vectorcraft_text::FALLBACK_FAMILY));
+        s.execute("text.create", &json!({"x": 10, "y": 90, "text": "Ab 雅楽", "font": "Inter"})).unwrap();
+        let inter = s.execute("text.fonts", &json!({})).unwrap().as_array().unwrap().iter().find(|f| f["family"] == "Inter").cloned().unwrap();
+        assert_eq!(inter["missingGlyphs"], 2, "雅 and 楽 come from a fallback font: {inter}");
+    }
+
     #[test]
     fn opened_documents_have_exact_text_bounds() {
         let mut s = Session::new();

crates/engine/src/cmd/object.rs

@@ -20,7 +20,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Transform",
             [],
             None,
-            "{matrix: [a,b,c,d,e,f], copy?: bool, ids?, strokes?: bool, corners?: bool} apply an affine to the selection (or ids); strokes/corners: Scale Strokes & Effects / Scale Corners (default: the preferences)",
+            "{matrix: [a,b,c,d,e,f], copy?: bool, ids?, strokes?: bool, corners?: bool, typeAreas?: bool} apply an affine to the selection (or ids); strokes/corners: Scale Strokes & Effects / Scale Corners (default: the preferences); typeAreas: area type among them (not type inside a group) reshapes its frame by the matrix and its text reflows at its size, as a bounding-box handle drag does (default: the type transforms too)",
             has_doc,
             transform
         ),
@@ -202,15 +202,18 @@ pub(crate) fn scaling(s: &mut Session, p: &Value) -> Scaling {
     Scaling { strokes, effects: strokes.then_some(vectorcraft_render::effects::scale_effect), keep_type_strokes: !strokes, keep_corners: !corners }
 }
 
-/// Apply `xf` to `ids` (`copy` param: duplicate first; `strokes`/`corners`: see [`scaling`]).
-/// Records Transform Again.
+/// Apply `xf` to `ids` (`copy` param: duplicate first; `strokes`/`corners`: see [`scaling`];
+/// `typeAreas`: see [`resize_type_area`]). Records Transform Again.
 pub(crate) fn apply_transform(s: &mut Session, label: &str, ids: Vec<NodeId>, xf: Affine, p: &Value) -> Result<Value> {
     let copy = bool_or(p, "copy", false);
+    let areas = bool_or(p, "typeAreas", false);
     let sc = if Scaling::factor(xf).is_some() { scaling(s, p) } else { Scaling::default() };
     let ids = s.edit(label, |d, sel| {
         let targets = if copy { duplicate_in(d, sel, &ids, Affine::IDENTITY)? } else { ids.clone() };
         for id in &targets {
-            if let Some(n) = d.node_mut(*id) {
+            if let Some(n) = d.node_mut(*id)
+                && !(areas && resize_type_area(n, xf))
+            {
                 n.transform(xf, sc);
             }
         }
@@ -224,6 +227,17 @@ pub(crate) fn apply_transform(s: &mut Session, label: &str, ids: Vec<NodeId>, xf
     Ok(json!({ "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>() }))
 }
 
+/// Area type resized by its bounding box: `xf` reshapes its frame (the type area) and the text
+/// reflows at its size. False for anything else (and type in perspective), which transforms as
+/// usual.
+fn resize_type_area(n: &mut Node, xf: Affine) -> bool {
+    if n.perspective.is_some() {
+        return false;
+    }
+    let NodeKind::Text(t) = &mut n.kind else { return false };
+    super::typecmd::reshape_area_with(t, |t| t.transform_area(xf))
+}
+
 fn transform(s: &mut Session, p: &Value) -> Result<Value> {
     let m = matrix_param(p, "matrix").ok_or_else(|| bad("object.transform", "missing matrix [a,b,c,d,e,f]"))?;
     let ids = match ids_param(p, "ids") {
@@ -375,20 +389,26 @@ fn send_to_current_layer(s: &mut Session, _: &Value) -> Result<Value> {
 
 fn group(s: &mut Session, _: &Value) -> Result<Value> {
     let ids = selected_roots(s)?;
-    let Some(top) = ids.last().copied() else { return Err(EngineError::Other("nothing selected".into())) };
     let gid = s.edit("Group", |d, sel| {
-        let (par, idx, _) = d.position(top).ok_or(EngineError::NoNode(top))?;
-        let gid = d.alloc_id();
-        d.insert(par, idx + 1, Node::group(gid, vec![]))?;
-        for id in &ids {
-            d.move_node(*id, Some(gid), usize::MAX)?;
-        }
+        let gid = group_nodes(d, &ids)?;
         sel.set([gid]);
         Ok(gid)
     })?;
     Ok(json!({ "id": gid.0 }))
 }
 
+/// Put `ids` (top-level objects, in paint order) in a new group where the front-most one was.
+pub(crate) fn group_nodes(d: &mut Document, ids: &[NodeId]) -> Result<NodeId> {
+    let Some(top) = ids.last().copied() else { return Err(EngineError::Other("nothing selected".into())) };
+    let (par, idx, _) = d.position(top).ok_or(EngineError::NoNode(top))?;
+    let gid = d.alloc_id();
+    d.insert(par, idx + 1, Node::group(gid, vec![]))?;
+    for id in ids {
+        d.move_node(*id, Some(gid), usize::MAX)?;
+    }
+    Ok(gid)
+}
+
 fn ungroup(s: &mut Session, _: &Value) -> Result<Value> {
     let ids = selected_roots(s)?;
     s.edit("Ungroup", |d, sel| {

crates/engine/src/cmd/prefscmds.rs

@@ -82,6 +82,8 @@ pub const UNITS: &[(&str, &str)] = &[
     ("feet", "Feet"),
 ];
 const LINE_STYLE: &[(&str, &str)] = &[("lines", "Lines"), ("dots", "Dots")];
+/// Performance › Graphics Processor (`gpuPreference`), read by the desktop app at startup.
+pub const GPU_PREFERENCES: &[(&str, &str)] = &[("powerSaving", "Power Saving (integrated)"), ("highPerformance", "High Performance (discrete)")];
 const BLACK: &[(&str, &str)] = &[("accurate", "Display All Blacks Accurately"), ("rich", "Display All Blacks as Rich Black")];
 const BLACK_OUT: &[(&str, &str)] = &[("accurate", "Output All Blacks Accurately"), ("rich", "Output All Blacks as Rich Black")];
 
@@ -260,9 +262,12 @@ pub const PREF_SPECS: &[PrefSpec] = &[
     p!("largeTabs", "User Interface", "", "Large Tabs", bool),
     p!("uiScaling", "User Interface", "UI Scaling", "Scale", num(0.75, 2.0, "×")),
     p!("scaleCursorWithUi", "User Interface", "UI Scaling", "Scale Cursor Proportional to UI", bool),
+    // `auto` or a language code the shell registers (`zh-hant`); the shell shows it as a dropdown.
+    p!("interfaceLanguage", "User Interface", "Language", "Language", text),
     // Performance
     p!("gpuPerformance", "Performance", "GPU Performance", "GPU Performance", bool),
     p!("animatedZoom", "Performance", "GPU Performance", "Animated Zoom", bool),
+    p!("gpuPreference", "Performance", "GPU Performance", "Graphics Processor", choice(GPU_PREFERENCES)),
     p!("historyStates", "Performance", "", "History States", int(5, 1000)),
     p!("realTimeDrawing", "Performance", "", "Real-time Drawing and Editing", bool),
     p!("renderThreads", "Performance", "", "Render Threads (-1 = Automatic)", int(-1, 64)),
@@ -390,6 +395,11 @@ pub fn validate(key: &str, v: &Value) -> std::result::Result<Value, String> {
                 Err(format!("`{key}` must be a #rrggbb colour"))
             }
         }
+        PrefKind::Text if key == "interfaceLanguage" => {
+            let s = v.as_str().map(str::trim).unwrap_or("");
+            let ok = !s.is_empty() && s.len() <= 16 && s.chars().all(|c| c.is_ascii_alphanumeric() || c == '-');
+            if ok { Ok(json!(s.to_ascii_lowercase())) } else { Err(format!("`{key}` must be `auto` or a language code such as `en` or `zh-hant`")) }
+        }
         PrefKind::Text => match v {
             Value::String(s) => Ok(json!(s)),
             _ => Err(format!("`{key}` must be a string")),

crates/engine/src/cmd/select.rs

@@ -188,7 +188,8 @@ fn key(s: &mut Session, p: &Value) -> Result<Value> {
     ok()
 }
 
-fn parse_refs(v: Option<&Value>) -> Vec<(usize, usize)> {
+/// `[[subpath, anchor]…]` anchor references (malformed entries are left out).
+pub(crate) fn parse_refs(v: Option<&Value>) -> Vec<(usize, usize)> {
     v.and_then(Value::as_array)
         .map(|a| a.iter().filter_map(|x| Some((x.get(0)?.as_u64()? as usize, x.get(1)?.as_u64()? as usize))).collect())
         .unwrap_or_default()

crates/engine/src/cmd/textedit.rs

@@ -45,7 +45,7 @@ pub fn specs() -> Vec<CommandSpec> {
             "Area / Path Type",
             [],
             None,
-            "{path: id, mode: \"area\"|\"onPath\", text?: \"\", at?: [x, y] (on-path start: nearest point), size?, font?} turn a path into an area-type frame or a type-on-a-path baseline (the path's paint is dropped) → {id}",
+            "{path: id, mode: \"area\"|\"onPath\", text?: \"\", vertical?: bool = false, at?: [x, y] (on-path start: nearest point), size?, font?} turn a path into an area-type frame or a type-on-a-path baseline (the path's paint is dropped) → {id}",
             has_doc,
             create_in_path
         ),
@@ -368,6 +368,7 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
     };
     let kind = if on_path { TextKind::OnPath { path: path.clone(), start } } else { TextKind::Area { frame: path.clone() } };
     let mut t = TextObject {
+        vertical: p.get("vertical").and_then(Value::as_bool).unwrap_or(false),
         kind,
         xf: Affine::IDENTITY,
         runs: vec![TextRun { text, style }],
@@ -404,6 +405,7 @@ fn headline_tracking(t: &TextObject, target: f64) -> Option<f64> {
     let head = edit::slice_runs(&t.runs, 0, end);
     let measure = |tr: f64| {
         let mut h = TextObject {
+            vertical: t.vertical,
             kind: TextKind::Point,
             xf: Affine::IDENTITY,
             runs: head.clone(),

crates/engine/src/cmd/typecmd.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use serde_json::{Value, json};
 use vectorcraft_doc::{Document, Justify, Node, NodeId, NodeKind, TextObject};
-use vectorcraft_geom::PathData;
+use vectorcraft_geom::{Affine, PathData, Vec2};
 
 use super::edit::selected_roots;
 use super::pathops::{len_param, num_param, shape_node};
@@ -13,6 +13,18 @@ use super::*;
 
 pub fn specs() -> Vec<CommandSpec> {
     vec![
+        cmd!("type.orientation.vertical", "Vertical", ["Type", "Orientation"], None, "{ids?|id?} set vertical writing", has_selection, |s, p| {
+            orientation(s, p, true)
+        }),
+        cmd!(
+            "type.orientation.horizontal",
+            "Horizontal",
+            ["Type", "Orientation"],
+            None,
+            "{ids?|id?} set horizontal writing",
+            has_selection,
+            |s, p| orientation(s, p, false)
+        ),
         cmd!(
             "type.createOutlines",
             "Create Outlines",
@@ -36,10 +48,19 @@ pub fn specs() -> Vec<CommandSpec> {
             "Area Type Options…",
             ["Type"],
             None,
-            "{ids?, rows?, columns?, gutter?: pt, inset?: pt, firstBaseline?: ascent|capHeight|xHeight|leading|fixed, firstBaselineMin?: pt} set the selected area type's options (none given: query) → the first object's options",
+            "{ids?, width?: pt, height?: pt, rows?, columns?, gutter?: pt, inset?: pt, firstBaseline?: ascent|capHeight|xHeight|leading|fixed, firstBaselineMin?: pt} set the selected area type's options; width and height size the type area from its top-left corner, along the type's own axes, and the text reflows at its size (none given: query) → the first object's options",
             has_selection,
             area_options
         ),
+        cmd!(
+            "text.reshapeArea",
+            "Reshape Type Area",
+            [],
+            None,
+            "{id, anchors: [[subpath, anchor]…], dx, dy} move anchors of area type's frame (the type area) by dx, dy points, with their handles; the text reflows at its size, through its thread too (what Direct Selection does dragging a frame corner or edge)",
+            has_doc,
+            reshape_area
+        ),
         cmd!(
             "text.fitHeadline",
             "Fit Headline",
@@ -61,6 +82,21 @@ pub fn specs() -> Vec<CommandSpec> {
     ]
 }
 
+fn orientation(s: &mut Session, p: &Value, vertical: bool) -> Result<Value> {
+    let ids = text_targets(s, p, "Text Orientation")?;
+    s.edit("Text Orientation", |d, _| {
+        for id in &ids {
+            let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else {
+                return Err(EngineError::NoNode(*id));
+            };
+            t.vertical = vertical;
+            refresh_bounds(t);
+        }
+        Ok(())
+    })?;
+    Ok(json!({"vertical": vertical, "ids": ids.iter().map(|id| id.0).collect::<Vec<_>>()}))
+}
+
 /// Recompute the layout bounds cache after a text edit.
 pub(crate) fn refresh_bounds(t: &mut TextObject) {
     let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), t);
@@ -238,25 +274,82 @@ fn set_style(s: &mut Session, p: &Value) -> Result<Value> {
     Ok(json!({ "ids": ids.iter().map(|i| i.0).collect::<Vec<_>>() }))
 }
 
+/// Reshape area type's frame with `f` ([`TextObject::transform_area`],
+/// [`TextObject::move_area_anchors`]) and lay its text out again. False, changing nothing, when
+/// `f` fails or the frame would reach past [`crate::MAX_COORD`] (the text flows over its height).
+pub(crate) fn reshape_area_with(t: &mut TextObject, f: impl FnOnce(&mut TextObject) -> bool) -> bool {
+    let before = t.kind.clone();
+    let within = |t: &TextObject| match &t.kind {
+        vectorcraft_doc::TextKind::Area { frame } => {
+            frame.bounds().is_some_and(|b| [b.x0, b.y0, b.x1, b.y1].iter().all(|v| v.abs() <= crate::MAX_COORD))
+        }
+        _ => false,
+    };
+    if !(f(t) && within(t)) {
+        t.kind = before;
+        return false;
+    }
+    refresh_bounds(t);
+    true
+}
+
+/// Area type's text, if `n` is area type.
+fn area_text(n: Option<&Node>) -> Option<&TextObject> {
+    match n.map(|n| &n.kind) {
+        Some(NodeKind::Text(t)) if matches!(t.kind, vectorcraft_doc::TextKind::Area { .. }) => Some(t),
+        _ => None,
+    }
+}
+
+/// The width and height of area type's frame in points, along the type's own axes, and the frame's
+/// bounds in text space.
+fn area_size(t: &TextObject) -> Option<(f64, f64, vectorcraft_geom::Rect)> {
+    let vectorcraft_doc::TextKind::Area { frame } = &t.kind else { return None };
+    let b = frame.bounds()?;
+    let [a, bb, c, d, _, _] = t.xf.as_coeffs();
+    Some((b.width() * a.hypot(bb), b.height() * c.hypot(d), b))
+}
+
+/// Size area type's frame to `w` × `h` points (None: keep that side) from its top-left corner,
+/// and lay its text out again. False when the frame doesn't change.
+fn size_area(t: &mut TextObject, w: Option<f64>, h: Option<f64>) -> bool {
+    let Some((cw, ch, b)) = area_size(t) else { return false };
+    let factor = |to: Option<f64>, cur: f64| match to {
+        Some(to) if cur > 1e-9 && (to - cur).abs() > 1e-9 => to / cur,
+        _ => 1.0,
+    };
+    let (sx, sy) = (factor(w, cw), factor(h, ch));
+    if sx == 1.0 && sy == 1.0 {
+        return false;
+    }
+    let o = Affine::translate(b.origin().to_vec2());
+    let a = t.xf * o * Affine::scale_non_uniform(sx, sy) * o.inverse() * t.xf.inverse();
+    reshape_area_with(t, |t| t.transform_area(a))
+}
+
 fn area_options(s: &mut Session, p: &Value) -> Result<Value> {
     const C: &str = "text.areaOptions";
     let ids: Vec<NodeId> = {
         let d = &s.doc()?.doc;
-        text_targets(s, p, C)?
-            .into_iter()
-            .filter(|i| matches!(d.node(*i).map(|n| &n.kind), Some(NodeKind::Text(t)) if matches!(t.kind, vectorcraft_doc::TextKind::Area { .. })))
-            .collect()
+        text_targets(s, p, C)?.into_iter().filter(|i| area_text(d.node(*i)).is_some()).collect()
     };
-    let first = ids.first().ok_or_else(|| bad(C, "select area type (text in a frame)"))?;
-    let current = match &s.doc()?.doc.node(*first).map(|n| &n.kind) {
-        Some(NodeKind::Text(t)) => t.area.clone(),
-        _ => return Err(bad(C, "select area type (text in a frame)")),
+    let first = *ids.first().ok_or_else(|| bad(C, "select area type (text in a frame)"))?;
+    let options = |s: &Session| -> Result<Value> {
+        let t = area_text(s.doc()?.doc.node(first)).ok_or_else(|| bad(C, "select area type (text in a frame)"))?;
+        let mut v = serde_json::to_value(&t.area).map_err(|e| EngineError::Other(e.to_string()))?;
+        if let (Some(o), Some((w, h, _))) = (v.as_object_mut(), area_size(t)) {
+            o.insert("width".into(), json!(w));
+            o.insert("height".into(), json!(h));
+        }
+        Ok(v)
     };
-    let mut v = serde_json::to_value(&current).map_err(|e| EngineError::Other(e.to_string()))?;
-    let mut changed = false;
+    let mut v = options(s)?;
+    let size = |k: &str| p.get(k).and_then(Value::as_f64).map(|x| x.clamp(1.0, 100_000.0));
+    let (w, h) = (size("width"), size("height"));
+    let mut changed = w.is_some() || h.is_some();
     if let (Some(o), Some(src)) = (v.as_object_mut(), p.as_object()) {
         for (k, val) in src {
-            if o.contains_key(k) && k != "ids" {
+            if o.contains_key(k) && !matches!(k.as_str(), "ids" | "width" | "height") {
                 o.insert(k.clone(), val.clone());
                 changed = true;
             }
@@ -271,23 +364,66 @@ fn area_options(s: &mut Session, p: &Value) -> Result<Value> {
     opts.gutter = opts.gutter.clamp(0.0, 10_000.0);
     opts.inset = opts.inset.clamp(0.0, 10_000.0);
     opts.first_baseline_min = opts.first_baseline_min.clamp(0.0, 10_000.0);
-    let out = serde_json::to_value(&opts).map_err(|e| EngineError::Other(e.to_string()))?;
     s.edit("Area Type Options", |d, _| {
         for id in &ids {
             if let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) {
                 t.area = opts.clone();
-                refresh_bounds(t);
+                // A resized frame has laid its text out again; otherwise the new options do here.
+                if !size_area(t, w, h) {
+                    refresh_bounds(t);
+                }
             }
         }
         Ok(())
     })?;
-    Ok(out)
+    options(s)
+}
+
+fn reshape_area(s: &mut Session, p: &Value) -> Result<Value> {
+    const C: &str = "text.reshapeArea";
+    let id = id_param(p, "id").ok_or_else(|| bad(C, "missing id"))?;
+    let mut refs = super::select::parse_refs(p.get("anchors"));
+    refs.sort_unstable();
+    refs.dedup();
+    if refs.is_empty() {
+        return Err(bad(C, "missing anchors [[subpath, anchor]…]"));
+    }
+    let d = Vec2::new(f64_req(p, "dx", C)?, f64_req(p, "dy", C)?);
+    let node = s.doc()?.doc.node(id);
+    if area_text(node).is_none() || node.is_some_and(|n| n.perspective.is_some()) {
+        return Err(bad(C, "not area type (text in a frame) outside perspective"));
+    }
+    s.edit("Reshape Type Area", |doc, _| {
+        let Some(NodeKind::Text(t)) = doc.node_mut(id).map(|n| &mut n.kind) else { return Err(EngineError::NoNode(id)) };
+        if !reshape_area_with(t, |t| t.move_area_anchors(&refs, d)) {
+            return Err(bad(C, "no such frame anchor, or the frame would reach past the canvas"));
+        }
+        Ok(())
+    })?;
+    ok()
 }
 
 #[cfg(test)]
 mod area_tests {
     use super::*;
 
+    #[test]
+    fn vertical_point_type_keeps_its_anchor_on_the_column_centre_line() {
+        let mut s = Session::new();
+        s.execute("file.new", &json!({"width": 400, "height": 400})).unwrap();
+        let id = s.execute("text.create", &json!({"x": 100, "y": 50, "text": "§§§§ abc"})).unwrap()["id"].as_u64().unwrap();
+        let bounds = |s: &Session| s.doc().unwrap().doc.node(NodeId(id)).unwrap().geometric_bounds().unwrap();
+        let wide = bounds(&s);
+        assert!(wide.width() > wide.height());
+        s.execute("select.set", &json!({"ids": [id]})).unwrap();
+        s.execute("type.orientation.vertical", &json!({})).unwrap();
+        let tall = bounds(&s);
+        assert!(tall.height() > tall.width(), "{tall:?}");
+        assert!((tall.center().x - 100.0).abs() < 6.0, "the anchor stays on the column's centre line: {tall:?}");
+        s.execute("edit.undo", &json!({})).unwrap();
+        assert_eq!(bounds(&s), wide);
+    }
+
     #[test]
     fn area_options_columns_change_layout() {
         let mut s = Session::new();

crates/engine/src/inspect.rs

@@ -29,7 +29,21 @@ pub fn node_summary(n: &Node) -> Value {
     if n.bbox_angle != 0.0 {
         v["rotation"] = json!(n.bbox_angle);
     }
-    if !n.is_container() {
+    if let NodeKind::Text(t) = &n.kind {
+        // Type shows its characters' paint: the first run's, as paint.proxies and the Stroke
+        // options read it. Fills and strokes of the type object itself, above or below its
+        // characters, come separately so the two stay apart.
+        let default = vectorcraft_doc::CharStyle::default();
+        let style = t.runs.first().map_or(&default, |r| &r.style);
+        v["fill"] = json!(style.fill.label());
+        v["stroke"] = json!(style.stroke.label());
+        v["strokeWidth"] = json!(if style.stroke.is_none() { 0.0 } else { style.stroke_width });
+        if n.appearance.fill().is_some() || n.appearance.stroke().is_some() {
+            v["objectFill"] = json!(n.appearance.fill_paint().label());
+            v["objectStroke"] = json!(n.appearance.stroke_paint().label());
+            v["objectStrokeWidth"] = json!(n.appearance.stroke_width());
+        }
+    } else if !n.is_container() {
         v["fill"] = json!(n.appearance.fill_paint().label());
         v["stroke"] = json!(n.appearance.stroke_paint().label());
         v["strokeWidth"] = json!(n.appearance.stroke_width());

crates/engine/src/lib.rs

@@ -391,9 +391,18 @@ pub struct Prefs {
     pub large_tabs: bool,
     pub ui_scaling: f64,
     pub scale_cursor_with_ui: bool,
+    /// UI language: `auto` (follow the system locale) or a language code such as `en`, `zh-hant`.
+    /// The list of languages belongs to the shell (`ui-egui` i18n); an unknown code reads as `auto`.
+    pub interface_language: String,
     // Performance
     pub gpu_performance: bool,
     pub animated_zoom: bool,
+    /// Which graphics processor the desktop app asks for at startup (it takes effect after a
+    /// restart): `powerSaving` (the integrated GPU on hybrid-graphics laptops) or `highPerformance`
+    /// (the discrete one). The canvas is rasterized on the CPU and only composited on the GPU, so
+    /// the integrated GPU is plenty; presenting from the discrete GPU through the integrated one
+    /// made some hybrid laptops flicker (#306). Single-GPU machines are unaffected.
+    pub gpu_preference: String,
     pub history_states: u32,
     pub real_time_drawing: bool,
     /// Rasterizer worker threads; -1 = automatic.
@@ -592,8 +601,10 @@ impl Default for Prefs {
             large_tabs: false,
             ui_scaling: 1.0,
             scale_cursor_with_ui: false,
+            interface_language: s("auto"),
             gpu_performance: true,
             animated_zoom: true,
+            gpu_preference: s("powerSaving"),
             history_states: 500,
             real_time_drawing: true,
             render_threads: -1,
@@ -1384,6 +1395,8 @@ mod tests_toolsettings;
 #[cfg(test)]
 mod tests_transparencygrid;
 #[cfg(test)]
+mod tests_typearea;
+#[cfg(test)]
 mod tests_units;
 #[cfg(test)]
 mod tests_webexport;

crates/engine/src/tests.rs

@@ -285,6 +285,39 @@ fn inspect_lists_everything() {
     assert!(s.commands().len() > 100);
 }
 
+/// Type reports the paint its characters show, and its own object-level paint apart from it.
+#[test]
+fn inspect_reports_the_paint_of_types_characters() {
+    let mut s = session();
+    let id = s.execute("text.create", &json!({"x": 50, "y": 60, "text": "HI", "size": 24})).unwrap()["id"].as_u64().unwrap();
+    s.execute("paint.setFill", &json!({"color": "#ff0000", "ids": [id]})).unwrap();
+    let node = |s: &mut Session| {
+        let v = s.execute("document.inspect", &json!({})).unwrap();
+        v["layers"][0]["children"].as_array().unwrap().iter().find(|n| n["id"] == id).cloned().unwrap()
+    };
+    let t = node(&mut s);
+    assert_eq!((t["fill"].as_str(), t["stroke"].as_str(), t["strokeWidth"].as_f64()), (Some("#ff0000"), Some("None"), Some(0.0)), "{t}");
+    assert!(t.get("objectFill").is_none(), "no object-level paint: {t}");
+    s.execute("paint.setFill", &json!({"color": "#0000ff", "ids": [id]})).unwrap();
+    s.execute("paint.setStroke", &json!({"color": "#00ff00", "ids": [id]})).unwrap();
+    s.execute("stroke.set", &json!({"weight": 3, "ids": [id]})).unwrap();
+    let t = node(&mut s);
+    assert_eq!((t["fill"].as_str(), t["stroke"].as_str(), t["strokeWidth"].as_f64()), (Some("#0000ff"), Some("#00ff00"), Some(3.0)), "{t}");
+    // An object-level fill on the type stays distinguishable from its characters' paint.
+    s.execute("appearance.addFill", &json!({"ids": [id]})).unwrap();
+    s.execute("paint.setFill", &json!({"color": "#ffff00", "item": 0, "ids": [id]})).unwrap();
+    let t = node(&mut s);
+    assert_eq!(t["objectFill"], "#ffff00", "{t}");
+    assert_eq!(t["fill"], "#0000ff", "{t}");
+    // A path keeps reporting its own appearance.
+    let r = s.execute("shape.rectangle", &json!({"x": 0, "y": 0, "width": 10, "height": 10})).unwrap()["id"].as_u64().unwrap();
+    s.execute("paint.setFill", &json!({"color": "#ff0000", "ids": [r]})).unwrap();
+    let v = s.execute("document.inspect", &json!({})).unwrap();
+    let rect = v["layers"][0]["children"].as_array().unwrap().iter().find(|n| n["id"] == r).cloned().unwrap();
+    assert_eq!(rect["fill"], "#ff0000");
+    assert!(rect.get("objectFill").is_none());
+}
+
 #[test]
 fn every_command_has_unique_id_and_doc() {
     let mut ids: Vec<&str> = command_specs().iter().map(|c| c.id).collect();

crates/engine/src/tests_build.rs

@@ -310,6 +310,56 @@ fn live_paint_bucket_tool_fills_face() {
     assert_eq!(s.doc().unwrap().selection.objects, vec![f.id]);
 }
 
+fn line(s: &mut Session, a: (f64, f64), b: (f64, f64)) -> NodeId {
+    let r = s.execute("shape.line", &json!({"x1": a.0, "y1": a.1, "x2": b.0, "y2": b.1})).unwrap();
+    NodeId(r["id"].as_u64().unwrap())
+}
+
+/// Crossing lines, as in the bug report: the Live Paint Bucket fills the area they enclose.
+#[test]
+fn live_paint_bucket_fills_an_area_enclosed_by_lines() {
+    let mut s = session();
+    let ids = [line(&mut s, (0.0, 0.0), (100.0, 100.0)), line(&mut s, (100.0, 0.0), (0.0, 100.0)), line(&mut s, (-10.0, 80.0), (110.0, 80.0))];
+    s.execute("select.set", &json!({"ids": ids.map(|i| i.0)})).unwrap();
+    let v = ViewInfo::default();
+    s.select_tool("livePaintBucket", v).unwrap();
+    s.paint.fill = Paint::solid(Color::rgb(1.0, 0.0, 1.0));
+    // Inside the triangle (20,80) (50,50) (80,80): highlighted, then filled.
+    s.pointer(&PointerEvent::new(PointerKind::Move, 50.0, 70.0), v).unwrap();
+    assert!(!s.overlays(v).is_empty(), "red face highlight");
+    s.pointer(&PointerEvent::new(PointerKind::Down, 50.0, 70.0), v).unwrap();
+    let g = s.doc().unwrap().selection.objects[0];
+    let gn = node(&s, g);
+    assert!(vectorcraft_tools::builder::is_live_paint(&gn));
+    assert_eq!(vectorcraft_tools::builder::faces(&gn).len(), 1);
+    let f = vectorcraft_tools::builder::face_at(&gn, vectorcraft_geom::Point::new(50.0, 70.0)).unwrap();
+    assert_eq!(f.appearance.fill_paint(), s.paint.fill);
+    assert!((vectorcraft_pathops::area(f.path_data().unwrap(), FillRule::NonZero).abs() - 900.0).abs() < 1e-6);
+    // The lines are edges, cut where they cross, and keep their stroke.
+    let edges = vectorcraft_tools::builder::edges(&gn);
+    assert_eq!(edges.len(), 9);
+    assert!(edges.iter().all(|e| !e.appearance.stroke_paint().is_none()));
+    // Outside the triangle there's nothing to fill.
+    assert!(s.execute("livePaint.fill", &json!({"group": g.0, "point": [50, 20]})).is_err());
+}
+
+#[test]
+fn a_line_across_a_live_paint_shape_splits_its_face() {
+    let mut s = session();
+    let r = rect(&mut s, 0.0, 0.0, 100.0, 50.0);
+    set_fill(&mut s, r, Color::rgb(1.0, 0.0, 0.0));
+    let l = line(&mut s, (40.0, -20.0), (60.0, 70.0));
+    s.execute("select.set", &json!({"ids": [r.0, l.0]})).unwrap();
+    let made = s.execute("livePaint.make", &json!({})).unwrap();
+    assert_eq!(made["faces"], 2, "{made}");
+    let g = NodeId(made["id"].as_u64().unwrap());
+    s.execute("livePaint.fill", &json!({"group": g.0, "point": [80, 25], "color": "#0000ff"})).unwrap();
+    let gn = node(&s, g);
+    let face = |x: f64| vectorcraft_tools::builder::face_at(&gn, vectorcraft_geom::Point::new(x, 25.0)).unwrap().appearance.fill_paint();
+    assert_eq!(face(10.0), Paint::solid(Color::rgb(1.0, 0.0, 0.0)), "the left half keeps the rectangle's fill");
+    assert_eq!(face(80.0), Paint::solid(Color::from_hex("#0000ff").unwrap()));
+}
+
 // ---------- Image Trace ----------
 
 /// A 100×100 image with a black disc (r = 30 px), placed at (50, 50) scaled ×2.

crates/engine/src/tests_file.rs

@@ -168,6 +168,33 @@ fn export_selection_crops_to_the_selection() {
     assert_eq!(text.matches("<path").count(), 1, "{text}");
 }
 
+/// A selection export reports the encoder's warnings like a whole-document export, and an empty
+/// list when nothing was approximated.
+#[test]
+fn export_selection_reports_the_encoders_warnings() {
+    let mut s = session();
+    s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 50, "height": 50})).unwrap();
+    s.execute("transparency.set", &json!({"blend": "Multiply"})).unwrap();
+    let warnings = |v: &serde_json::Value| v["warnings"].as_array().cloned().unwrap_or_else(|| panic!("no warnings key: {v}"));
+    // Control: nothing approximated.
+    let plain = s.execute("document.exportSelection", &json!({"format": "svg"})).unwrap();
+    assert_eq!(plain["format"], "svg");
+    assert!(warnings(&plain).is_empty(), "{plain}");
+    for (format, options, says) in [
+        ("webp", json!({"lossless": false}), "lossless"),
+        ("svg", json!({"profile": "tiny12"}), "blend"),
+        ("pdf", json!({"createLayers": true, "compatibility": "1.4"}), "layers"),
+    ] {
+        let mut p = options.clone();
+        p["format"] = json!(format);
+        let sel = s.execute("document.exportSelection", &p).unwrap();
+        let doc = s.execute("document.export", &p).unwrap();
+        let w = warnings(&sel);
+        assert!(w.iter().any(|w| w.as_str().unwrap_or("").to_lowercase().contains(says)), "{format}: {sel}");
+        assert_eq!(w, warnings(&doc), "{format}: the same warnings as a whole-document export");
+    }
+}
+
 #[test]
 fn template_opens_as_untitled() {
     let mut s = session();
@@ -206,3 +233,30 @@ fn raster_export_too_large_is_an_error_not_a_crash() {
     assert!(std::fs::read(&path).unwrap().starts_with(b"\x89PNG"));
     let _ = std::fs::remove_dir_all(dir);
 }
+
+/// Japanese file and folder names save, open, export and title documents as typed: the native
+/// format, SVG, PNG and PDF, in a folder with a Japanese name too.
+#[test]
+fn japanese_file_names_save_open_and_export() {
+    let mut s = session();
+    s.execute("shape.rectangle", &json!({"x": 10, "y": 10, "width": 80, "height": 40})).unwrap();
+    s.execute("text.create", &json!({"x": 10, "y": 80, "text": "日本語のテキスト"})).unwrap();
+    let dir = std::env::temp_dir().join(format!("vc-日本語フォルダ-{}", std::process::id()));
+    std::fs::create_dir_all(&dir).unwrap();
+    let path = dir.join("運動会カード（最終版）・2024.vectorcraft");
+    s.execute("document.save", &json!({"path": path.to_string_lossy()})).unwrap();
+    assert!(path.exists());
+    assert_eq!(s.doc().unwrap().title(), "運動会カード（最終版）・2024.vectorcraft", "the tab names the file as typed");
+    s.execute("document.open", &json!({"path": path.to_string_lossy()})).unwrap();
+    let d = s.doc().unwrap();
+    assert_eq!(d.path.as_deref(), Some(path.to_string_lossy().as_ref()));
+    let mut found = false;
+    d.doc.walk(|n| found |= matches!(&n.kind, vectorcraft_doc::NodeKind::Text(t) if t.plain_text() == "日本語のテキスト"));
+    assert!(found, "the Japanese text comes back");
+    for (format, name) in [("svg", "書き出し.svg"), ("png", "書き出し.png"), ("pdf", "書き出し.pdf")] {
+        let out = dir.join(name);
+        s.execute("document.export", &json!({"format": format, "path": out.to_string_lossy()})).unwrap();
+        assert!(std::fs::metadata(&out).is_ok_and(|m| m.len() > 0), "{name}");
+    }
+    let _ = std::fs::remove_dir_all(dir);
+}

crates/engine/src/tests_fontlist.rs

@@ -14,14 +14,14 @@ fn names(v: &Value) -> Vec<String> {
 fn the_font_list_names_every_available_family_with_its_styles() {
     let mut s = Session::new();
     let fams = names(&s.execute("text.fontList", &json!({})).unwrap()["families"]);
-    assert_eq!(fams, FontDb::global().families());
+    assert_eq!(fams, *FontDb::global().menu_family_list());
     for f in ["Source Sans 3", "Source Serif 4", "Inter", "JetBrains Mono"] {
         assert!(fams.iter().any(|x| x == f), "{f}");
     }
     // Every installed family, though nothing asked for system fonts.
     let installed = FontDb::with_font_dirs(system_font_dirs());
     installed.load_system_fonts();
-    let missing: Vec<String> = installed.families().into_iter().filter(|f| !fams.contains(f)).collect();
+    let missing: Vec<String> = installed.menu_family_list().iter().filter(|f| !fams.contains(f)).cloned().collect();
     assert!(missing.is_empty(), "{missing:?}");
     let r = s.execute("text.fontList", &json!({"family": "source sans 3"})).unwrap();
     assert_eq!(r["family"], "Source Sans 3");
@@ -38,7 +38,7 @@ fn refreshing_the_font_list_redraws_type_without_editing_the_document() {
     s.doc_mut().unwrap().mark_saved();
     let revision = s.doc().unwrap().revision;
     let r = s.execute("text.rescanFonts", &json!({})).unwrap();
-    assert_eq!(r["families"], json!(FontDb::global().families().len()));
+    assert_eq!(r["families"], json!(FontDb::global().menu_family_list().len()));
     assert!(r["faces"].is_u64());
     let d = s.doc().unwrap();
     assert!(d.revision > revision, "the canvas redraws");

crates/engine/src/tests_prefs.rs

@@ -122,3 +122,33 @@ fn prefs_serde_round_trip_and_tolerates_missing_fields() {
     assert_eq!(partial.keyboard_increment, 4.0);
     assert_eq!(partial.corner_radius, 12.0);
 }
+
+/// Performance › Graphics Processor (#306): power saving by default, set by value or label, kept
+/// through a save/load round trip, and a bad value is an error that changes nothing.
+#[test]
+fn gpu_preference_defaults_to_power_saving_and_validates() {
+    let mut s = Session::new();
+    assert_eq!(s.prefs.gpu_preference, "powerSaving");
+    assert_eq!(s.execute("prefs.get", &json!({"key": "gpuPreference"})).unwrap(), json!("powerSaving"));
+    s.execute("prefs.set", &json!({"key": "gpuPreference", "value": "highPerformance"})).unwrap();
+    assert_eq!(s.prefs.gpu_preference, "highPerformance");
+    s.execute("prefs.set", &json!({"key": "gpuPreference", "value": "Power Saving (integrated)"})).unwrap();
+    assert_eq!(s.prefs.gpu_preference, "powerSaving");
+    for bad in [json!("turbo"), json!(""), json!(1), json!(null), json!(["highPerformance"])] {
+        assert!(s.execute("prefs.set", &json!({"key": "gpuPreference", "value": bad})).is_err(), "{bad}");
+        assert_eq!(s.prefs.gpu_preference, "powerSaving");
+    }
+    let p = Prefs { gpu_preference: "highPerformance".into(), ..Default::default() };
+    let back: Prefs = serde_json::from_value(p.to_json()).unwrap();
+    assert_eq!(back.gpu_preference, "highPerformance");
+    // Preference files written before the preference existed get the default.
+    let old: Prefs = serde_json::from_value(json!({"gpuPerformance": true})).unwrap();
+    assert_eq!(old.gpu_preference, "powerSaving");
+    let l = s.execute("prefs.list", &json!({})).unwrap();
+    let row = l.as_array().unwrap().iter().find(|e| e["key"] == "gpuPreference").unwrap().clone();
+    assert_eq!(row["category"], "Performance");
+    assert_eq!(row["options"], json!(["powerSaving", "highPerformance"]));
+    s.execute("prefs.set", &json!({"key": "gpuPreference", "value": "highPerformance"})).unwrap();
+    s.execute("prefs.reset", &json!({"category": "Performance"})).unwrap();
+    assert_eq!(s.prefs.gpu_preference, "powerSaving");
+}

crates/engine/src/tests_scalestrokes.rs

@@ -153,6 +153,61 @@ fn scale_corners_keeps_or_scales_live_corner_radii() {
     assert!((n.geometric_bounds().unwrap().width() - 400.0).abs() < 1e-6);
 }
 
+/// The extent along x and y of each corner arc of an upright live rounded rectangle's path.
+fn corner_spans(n: &Node) -> Vec<(f64, f64)> {
+    let NodeKind::Path { path, .. } = &n.kind else { panic!("not a path") };
+    let a = &path.subpaths[0].anchors;
+    assert_eq!(a.len(), 8, "a rounded rectangle");
+    [(1, 2), (3, 4), (5, 6), (7, 0)].iter().map(|(i, j)| ((a[*j].p.x - a[*i].p.x).abs(), (a[*j].p.y - a[*i].p.y).abs())).collect()
+}
+
+/// Every corner is a circular arc of radius `r`.
+fn round_corners(n: &Node, r: f64) -> bool {
+    corner_spans(n).iter().all(|(x, y)| (x - r).abs() < 1e-9 && (y - r).abs() < 1e-9)
+}
+
+#[test]
+fn live_corners_stay_circular_when_a_rectangle_is_scaled_unevenly() {
+    // #291: a rounded square widened into a long rectangle keeps round corners.
+    let mut s = session();
+    let id = id_of(&run(&mut s, "shape.rectangle", json!({"x": 0, "y": 0, "width": 100, "height": 100, "radius": 10})));
+    run(&mut s, "object.scale", json!({"sx": 300, "sy": 100, "corners": false}));
+    let n = node(&s, id);
+    assert!((n.geometric_bounds().unwrap().width() - 300.0).abs() < 1e-9);
+    assert!(round_corners(&n, 10.0), "{:?}", corner_spans(&n));
+    let NodeKind::Path { live: Some(LiveShape::Rectangle { w, h, radii, .. }), .. } = &n.kind else { panic!("not live") };
+    assert!((w - 300.0).abs() < 1e-9 && (h - 100.0).abs() < 1e-9 && (radii[0] - 10.0).abs() < 1e-9, "the panels read document units");
+    // Scale Corners on: the radius scales by the mean scale (√(2 × 0.5) = 1 here, 2 below).
+    run(&mut s, "object.scale", json!({"sx": 200, "sy": 50, "corners": true}));
+    assert!(round_corners(&node(&s, id), 10.0), "{:?}", corner_spans(&node(&s, id)));
+    run(&mut s, "object.scale", json!({"sx": 100, "sy": 400, "corners": true}));
+    assert!(round_corners(&node(&s, id), 20.0), "{:?}", corner_spans(&node(&s, id)));
+    // Undo brings each step back.
+    run(&mut s, "edit.undo", json!({}));
+    run(&mut s, "edit.undo", json!({}));
+    assert!(round_corners(&node(&s, id), 10.0));
+    run(&mut s, "edit.undo", json!({}));
+    assert!(round_corners(&node(&s, id), 10.0));
+    assert!((node(&s, id).geometric_bounds().unwrap().width() - 100.0).abs() < 1e-9);
+}
+
+#[test]
+fn a_bounding_box_drag_keeps_live_corners_circular() {
+    // The Selection tool's handle drag previews `object.transform` from the shape as it began.
+    let mut s = session();
+    let id = id_of(&run(&mut s, "shape.rectangle", json!({"x": 50, "y": 50, "width": 100, "height": 100, "radius": 25})));
+    s.begin_interaction("Scale").unwrap();
+    for sx in [1.5, 2.5, 4.0] {
+        // Dragging the right-middle handle: scaled about the left edge.
+        s.preview("object.transform", &json!({"matrix": [sx, 0, 0, 1, 50.0 - 50.0 * sx, 0]})).unwrap();
+    }
+    s.commit_interaction().unwrap();
+    let n = node(&s, id);
+    let b = n.geometric_bounds().unwrap();
+    assert!((b.x0 - 50.0).abs() < 1e-9 && (b.width() - 400.0).abs() < 1e-9 && (b.height() - 100.0).abs() < 1e-9, "{b:?}");
+    assert!(round_corners(&n, 25.0), "{:?}", corner_spans(&n));
+}
+
 #[test]
 fn the_journal_records_the_scale_options_used() {
     let mut s = session();

crates/engine/src/tests_textedit.rs

@@ -157,6 +157,98 @@ fn undo_during_a_drag_takes_back_only_the_drag() {
     assert_eq!(b.x0, 100.0, "back where it was: {b:?}");
 }
 
+#[test]
+fn ime_composition_shows_in_place_and_commits_as_one_step() {
+    // Romaji → kana → conversion → commit, as the macOS Japanese IME sends it.
+    let mut s = session();
+    let v = ViewInfo::default();
+    s.select_tool("type", v).unwrap();
+    click(&mut s, 200.0, 200.0);
+    let id = s.doc().unwrap().selection.objects[0];
+    let created = undo_labels(&s).len();
+    s.tool_text("曲:", v).unwrap();
+    for (t, r) in [("g", 1..1), ("が", 1..1), ("がg", 2..2), ("ががく", 3..3)] {
+        s.tool_preedit(t, Some(r), v).unwrap();
+        assert_eq!(obj(&s, id).plain_text(), format!("曲:{t}"), "marked text lays out in place");
+        assert!(s.tool_composing());
+    }
+    // Conversion: the active clause is the whole word.
+    s.tool_preedit("雅楽", Some(0..2), v).unwrap();
+    assert_eq!(obj(&s, id).plain_text(), "曲:雅楽");
+    assert_eq!(s.tool_options()["composing"], json!(true));
+    // macOS clears the marked text, then commits.
+    s.tool_preedit("", None, v).unwrap();
+    s.tool_text("雅楽", v).unwrap();
+    assert!(!s.tool_composing());
+    assert_eq!(obj(&s, id).plain_text(), "曲:雅楽");
+    assert_eq!(s.tool_options()["caret"], json!("曲:雅楽".len()));
+    // Typing goes on after the commit, in the same session.
+    s.tool_text("。", v).unwrap();
+    key(&mut s, ToolKey::Escape, Mods::default());
+    assert_eq!(obj(&s, id).plain_text(), "曲:雅楽。");
+    assert_eq!(undo_labels(&s).len(), created + 1, "one undo step for the session");
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(obj(&s, id).plain_text(), "");
+}
+
+#[test]
+fn ime_cancel_leaves_no_undo_step_and_keeps_the_text() {
+    let mut s = session();
+    let v = ViewInfo::default();
+    let id = text(&mut s, "雅楽");
+    s.select_tool("type", v).unwrap();
+    let t = obj(&s, id);
+    let lay = vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t);
+    let (a, b) = vectorcraft_text::caret_position(&lay, "雅楽".len());
+    let p = t.xf * a.midpoint(b);
+    click(&mut s, p.x - 0.1, p.y);
+    assert!(s.tool_wants_text());
+    s.set_tool_option("select", &json!({"start": 6, "end": 6}));
+    let before = undo_labels(&s).len();
+    s.tool_preedit("えんそう", Some(4..4), v).unwrap();
+    assert_eq!(obj(&s, id).plain_text(), "雅楽えんそう");
+    // Escape in the IME: the marked text goes, nothing else changes.
+    s.tool_preedit("", None, v).unwrap();
+    assert!(!s.tool_composing());
+    assert!(!s.in_interaction(), "a cancelled composition leaves no typing session");
+    assert_eq!(obj(&s, id).plain_text(), "雅楽");
+    assert_eq!(undo_labels(&s).len(), before);
+    // A stray clear (no composition) never deletes the selection.
+    s.set_tool_option("select", &json!({"start": 0, "end": 3}));
+    s.tool_preedit("", None, v).unwrap();
+    assert_eq!(obj(&s, id).plain_text(), "雅楽");
+    // A composition over a selection replaces it.
+    s.tool_preedit("が", Some(1..1), v).unwrap();
+    s.tool_preedit("", None, v).unwrap();
+    s.tool_text("我", v).unwrap();
+    assert_eq!(obj(&s, id).plain_text(), "我楽");
+}
+
+#[test]
+fn clicking_away_keeps_marked_text_as_typed_and_undo_mid_composition_is_safe() {
+    let mut s = session();
+    let v = ViewInfo::default();
+    s.select_tool("type", v).unwrap();
+    click(&mut s, 200.0, 200.0);
+    let id = s.doc().unwrap().selection.objects[0];
+    s.tool_preedit("しょうこ", Some(4..4), v).unwrap();
+    // Keys belong to the IME while it composes.
+    key(&mut s, ToolKey::Backspace, Mods::default());
+    assert_eq!(obj(&s, id).plain_text(), "しょうこ");
+    click(&mut s, 600.0, 500.0);
+    assert!(!s.tool_composing());
+    assert_eq!(obj(&s, id).plain_text(), "しょうこ", "the marked text stays, committed");
+    // The UI holds Undo back while composing; if it comes anyway, the session is committed first.
+    click(&mut s, 50.0, 50.0);
+    let id2 = s.doc().unwrap().selection.objects[0];
+    s.tool_preedit("ひちりき", Some(4..4), v).unwrap();
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!(!s.tool_composing());
+    assert_eq!(obj(&s, id2).plain_text(), "");
+    s.execute("edit.redo", &json!({})).unwrap();
+    assert_eq!(obj(&s, id2).plain_text(), "ひちりき");
+}
+
 #[test]
 fn type_tool_selection_replace_and_delete() {
     let mut s = session();
@@ -236,6 +328,23 @@ fn select_all_and_cut_like_ui() {
     assert_eq!(obj(&s, id).plain_text(), "abc defabc def");
 }
 
+#[test]
+fn a_frame_dragged_with_the_type_tools_is_the_dragged_rectangle() {
+    for tool in ["type", "verticalType"] {
+        let mut s = session();
+        let v = ViewInfo::default();
+        s.select_tool(tool, v).unwrap();
+        for (k, x, y) in [(PointerKind::Down, 100.0, 100.0), (PointerKind::Drag, 300.0, 180.0), (PointerKind::Up, 300.0, 180.0)] {
+            s.pointer(&PointerEvent::new(k, x, y), v).unwrap();
+        }
+        let t = obj(&s, s.doc().unwrap().selection.objects[0]);
+        let TextKind::Area { frame } = &t.kind else { panic!("{tool}: not area type") };
+        let b = frame.bounds().unwrap();
+        let (a, z) = (t.xf * Point::new(b.x0, b.y0), t.xf * Point::new(b.x1, b.y1));
+        assert!((a - Point::new(100.0, 100.0)).hypot() < 1e-9 && (z - Point::new(300.0, 180.0)).hypot() < 1e-9, "{tool}: {a:?} {z:?}");
+    }
+}
+
 #[test]
 fn area_type_from_a_circle_keeps_glyphs_inside() {
     let mut s = session();
@@ -378,3 +487,22 @@ fn type_tool_state_does_not_leak_across_documents() {
     assert_eq!(obj(&s, id).plain_text(), "First");
     assert!(!s.in_interaction());
 }
+
+#[test]
+fn vertical_text_creation_orientation_and_persistence() {
+    let mut s = session();
+    let r = s.execute("text.create", &json!({"x":100,"y":100,"text":"日本語", "vertical":true})).unwrap();
+    let id = NodeId(r["id"].as_u64().unwrap());
+    let t = obj(&s, id);
+    assert!(t.vertical);
+    let round: TextObject = serde_json::from_value(serde_json::to_value(&t).unwrap()).unwrap();
+    assert!(round.vertical);
+    s.execute("type.orientation.horizontal", &json!({"id":id.0})).unwrap();
+    assert!(!obj(&s, id).vertical);
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert!(obj(&s, id).vertical);
+    let old = serde_json::to_value(TextObject::point(Point::ZERO, "old", Default::default())).unwrap();
+    assert!(old.get("vertical").is_none());
+    let old: TextObject = serde_json::from_value(old).unwrap();
+    assert!(!old.vertical);
+}

crates/engine/src/tests_typearea.rs

@@ -0,0 +1,269 @@
+//! Resizing area type (#252): a bounding-box handle drag and Area Type Options size the type area
+//! and the text reflows at its size; Direct Selection reshapes the frame by a corner or an edge.
+//! Point type still scales.
+
+use serde_json::{Value, json};
+use vectorcraft_doc::{NodeKind, TextKind, TextObject};
+use vectorcraft_geom::{Affine, Point, Rect};
+use vectorcraft_text::TextLayout;
+use vectorcraft_tools::bbox::Handle;
+use vectorcraft_tools::{Mods, PointerEvent, PointerKind};
+
+use super::*;
+
+const STORY: &str = "The quick brown fox jumps over the lazy dog. A second sentence follows the first one here. Then a third one ends it.";
+
+fn session() -> Session {
+    let mut s = Session::new();
+    s.execute("file.new", &json!({"width": 800, "height": 600})).unwrap();
+    s
+}
+
+fn id_of(v: &Value) -> NodeId {
+    NodeId(v["id"].as_u64().unwrap())
+}
+
+/// 12 pt area type in a `w` × `h` frame at (`x`, `y`).
+fn area(s: &mut Session, x: f64, y: f64, w: f64, h: f64, text: &str) -> NodeId {
+    id_of(&s.execute("text.create", &json!({"x": x, "y": y, "size": 12, "area": {"width": w, "height": h}, "text": text})).unwrap())
+}
+
+fn sel(s: &mut Session, ids: &[NodeId]) {
+    s.execute("select.set", &json!({"ids": ids.iter().map(|i| i.0).collect::<Vec<_>>()})).unwrap();
+}
+
+fn text(s: &Session, id: NodeId) -> TextObject {
+    match &s.doc().unwrap().doc.node(id).unwrap().kind {
+        NodeKind::Text(t) => (**t).clone(),
+        k => panic!("not text: {k:?}"),
+    }
+}
+
+/// The frame's anchors in text space.
+fn corners(s: &Session, id: NodeId) -> Vec<Point> {
+    match text(s, id).kind {
+        TextKind::Area { frame } => frame.anchors().map(|(_, _, a)| a.p).collect(),
+        k => panic!("not area type: {k:?}"),
+    }
+}
+
+fn frame(s: &Session, id: NodeId) -> Rect {
+    match text(s, id).kind {
+        TextKind::Area { frame } => frame.bounds().unwrap(),
+        k => panic!("not area type: {k:?}"),
+    }
+}
+
+fn layout(s: &Session, id: NodeId) -> TextLayout {
+    vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &text(s, id))
+}
+
+fn undo_len(s: &Session) -> usize {
+    s.doc().unwrap().history.undo.len()
+}
+
+fn last_step(s: &Session) -> String {
+    s.doc().unwrap().history.undo.last().unwrap().label.clone()
+}
+
+/// Press, drag and release `tool` from `from` to `to`.
+fn drag(s: &mut Session, tool: &str, from: Point, to: Point) {
+    let v = ViewInfo::default();
+    s.select_tool(tool, v).unwrap();
+    for (kind, p) in [(PointerKind::Down, from), (PointerKind::Drag, to), (PointerKind::Up, to)] {
+        s.pointer(&PointerEvent::new(kind, p.x, p.y).with_mods(Mods::default()), v).unwrap();
+    }
+    assert!(!s.in_interaction());
+}
+
+fn near(a: Point, b: Point) -> bool {
+    a.distance(b) < 1e-6
+}
+
+#[test]
+fn a_handle_drag_resizes_the_type_area_and_the_text_reflows() {
+    let mut s = session();
+    let id = area(&mut s, 40.0, 40.0, 120.0, 40.0, STORY);
+    let before = layout(&s, id);
+    assert!(before.overflow, "the story overflows 120 × 40");
+    sel(&mut s, &[id]);
+    let n = undo_len(&s);
+    // The bounding box's bottom-right handle, from (160, 80) to (200, 140): 160 × 100.
+    drag(&mut s, "selection", Point::new(160.0, 80.0), Point::new(200.0, 140.0));
+    assert_eq!(undo_len(&s), n + 1, "one step");
+    assert_eq!(last_step(&s), "Resize Type Area");
+    let r = frame(&s, id);
+    assert!(near(r.origin(), Point::ZERO) && (r.width() - 160.0).abs() < 1e-6 && (r.height() - 100.0).abs() < 1e-6, "{r:?}");
+    let t = text(&s, id);
+    assert_eq!(t.xf, Affine::translate((40.0, 40.0)), "the type isn't scaled");
+    assert!(t.runs.iter().all(|r| r.style.size == 12.0));
+    let after = layout(&s, id);
+    assert!(after.lines.len() > before.lines.len(), "more lines fit: {} → {}", before.lines.len(), after.lines.len());
+    assert!(after.glyphs.len() > before.glyphs.len());
+    assert!(!after.overflow, "the whole story fits 160 × 100");
+    // The bounding box hugs the new frame.
+    assert_eq!(s.doc().unwrap().doc.node(id).unwrap().geometric_bounds(), Some(Rect::new(40.0, 40.0, 200.0, 140.0)));
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(frame(&s, id), Rect::new(0.0, 0.0, 120.0, 40.0));
+    assert!(layout(&s, id).overflow);
+}
+
+#[test]
+fn point_type_still_scales_with_its_handles() {
+    let mut s = session();
+    let id = id_of(&s.execute("text.create", &json!({"x": 40, "y": 40, "size": 12, "text": "Hello"})).unwrap());
+    sel(&mut s, &[id]);
+    let b = s.transform_box(&s.doc().unwrap().selection.objects).unwrap();
+    let (tl, br) = (b.to_doc() * Handle::TopLeft.pos(b.rect), b.to_doc() * Handle::BottomRight.pos(b.rect));
+    drag(&mut s, "selection", br, tl + (br - tl) * 2.0);
+    assert_eq!(last_step(&s), "Scale");
+    let c = text(&s, id).xf.as_coeffs();
+    assert!((c[0] - 2.0).abs() < 1e-6 && (c[3] - 2.0).abs() < 1e-6, "the type doubles: {c:?}");
+}
+
+#[test]
+fn with_other_objects_the_type_area_resizes_and_the_others_scale() {
+    let mut s = session();
+    let id = area(&mut s, 40.0, 40.0, 120.0, 40.0, STORY);
+    let r = id_of(&s.execute("shape.rectangle", &json!({"x": 40, "y": 100, "width": 120, "height": 20})).unwrap());
+    sel(&mut s, &[id, r]);
+    // The box spans (40, 40)–(160, 120); its right handle doubles the width.
+    drag(&mut s, "selection", Point::new(160.0, 80.0), Point::new(280.0, 80.0));
+    assert_eq!(last_step(&s), "Scale");
+    assert_eq!(s.doc().unwrap().doc.node(r).unwrap().geometric_bounds(), Some(Rect::new(40.0, 100.0, 280.0, 120.0)));
+    assert_eq!(frame(&s, id), Rect::new(0.0, 0.0, 240.0, 40.0));
+    assert_eq!(text(&s, id).xf, Affine::translate((40.0, 40.0)));
+}
+
+#[test]
+fn a_rotated_type_area_resizes_along_its_own_axes() {
+    let mut s = session();
+    let id = area(&mut s, 40.0, 40.0, 120.0, 40.0, STORY);
+    sel(&mut s, &[id]);
+    s.execute("object.rotate", &json!({"angle": 30, "absolute": true})).unwrap();
+    let xf = text(&s, id).xf;
+    let b = s.transform_box(&[id]).unwrap();
+    let right = b.to_doc() * Handle::Right.pos(b.rect);
+    let along = (b.to_doc() * Handle::Right.pos(b.rect)) - (b.to_doc() * Handle::Left.pos(b.rect));
+    drag(&mut s, "selection", right, right + along * 0.5);
+    assert_eq!(text(&s, id).xf, xf, "the type keeps its size and angle");
+    let r = frame(&s, id);
+    assert!((r.width() - 180.0).abs() < 1e-6 && (r.height() - 40.0).abs() < 1e-6, "still a rectangle, 180 × 40: {r:?}");
+    assert_eq!(corners(&s, id).len(), 4);
+}
+
+#[test]
+fn direct_selection_drags_a_frame_corner_or_edge() {
+    let mut s = session();
+    let id = area(&mut s, 40.0, 40.0, 120.0, 40.0, STORY);
+    let glyphs = layout(&s, id).glyphs.len();
+    let n = undo_len(&s);
+    // The bottom-right corner, not selected yet: the corner moves, the others stay.
+    drag(&mut s, "directSelection", Point::new(160.0, 80.0), Point::new(200.0, 140.0));
+    assert_eq!(s.doc().unwrap().selection.objects, vec![id]);
+    assert_eq!(undo_len(&s), n + 1, "one step");
+    assert_eq!(last_step(&s), "Reshape Type Area");
+    let c = corners(&s, id);
+    assert!(near(c[0], Point::ZERO) && near(c[1], Point::new(120.0, 0.0)) && near(c[3], Point::new(0.0, 40.0)), "{c:?}");
+    assert!(near(c[2], Point::new(160.0, 100.0)), "{c:?}");
+    assert!(layout(&s, id).glyphs.len() > glyphs, "more text fits the larger area");
+    assert_eq!(text(&s, id).xf, Affine::translate((40.0, 40.0)));
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(frame(&s, id), Rect::new(0.0, 0.0, 120.0, 40.0));
+    // The right edge: both its ends move, and the area stays a rectangle.
+    drag(&mut s, "directSelection", Point::new(160.0, 60.0), Point::new(180.0, 60.0));
+    assert_eq!(frame(&s, id), Rect::new(0.0, 0.0, 140.0, 40.0));
+    assert_eq!(text(&s, id).runs[0].style.size, 12.0);
+}
+
+#[test]
+fn a_resized_frame_reflows_its_thread() {
+    let mut s = session();
+    let a = area(&mut s, 40.0, 40.0, 120.0, 40.0, STORY);
+    let b = area(&mut s, 300.0, 40.0, 120.0, 200.0, "");
+    sel(&mut s, &[a, b]);
+    s.execute("text.thread.create", &json!({})).unwrap();
+    let rest = text(&s, b).plain_text().len();
+    assert!(rest > 0, "the overflow flows on");
+    // Bounding-box resize of the first frame to 160 × 100, as the Selection tool sends it.
+    let m = Affine::translate((40.0, 40.0)) * Affine::scale_non_uniform(160.0 / 120.0, 100.0 / 40.0) * Affine::translate((-40.0, -40.0));
+    let c = m.as_coeffs();
+    s.execute("object.transform", &json!({"ids": [a.0], "matrix": c, "typeAreas": true})).unwrap();
+    assert!(text(&s, b).plain_text().len() < rest, "the second frame holds less");
+    assert_eq!(text(&s, a).plain_text().len() + text(&s, b).plain_text().len(), STORY.len());
+}
+
+#[test]
+fn area_type_options_size_the_type_area() {
+    let mut s = session();
+    let id = area(&mut s, 40.0, 40.0, 120.0, 40.0, STORY);
+    sel(&mut s, &[id]);
+    let q = s.execute("text.areaOptions", &json!({})).unwrap();
+    assert_eq!((q["width"].as_f64(), q["height"].as_f64()), (Some(120.0), Some(40.0)));
+    let n = undo_len(&s);
+    let r = s.execute("text.areaOptions", &json!({"width": 160, "height": 100})).unwrap();
+    assert_eq!((r["width"].as_f64(), r["height"].as_f64()), (Some(160.0), Some(100.0)));
+    assert_eq!(frame(&s, id), Rect::new(0.0, 0.0, 160.0, 100.0));
+    assert_eq!(text(&s, id).xf, Affine::translate((40.0, 40.0)));
+    assert!(!layout(&s, id).overflow);
+    // The dialog's OK sends the size back unchanged with the other options: only those change.
+    s.execute("text.areaOptions", &json!({"width": 160, "height": 100, "inset": 4})).unwrap();
+    assert_eq!(frame(&s, id), Rect::new(0.0, 0.0, 160.0, 100.0));
+    assert_eq!(undo_len(&s), n + 2);
+    s.execute("edit.undo", &json!({})).unwrap();
+    s.execute("edit.undo", &json!({})).unwrap();
+    assert_eq!(frame(&s, id), Rect::new(0.0, 0.0, 120.0, 40.0));
+    // Type scaled 200%: sizes are in points on the page, along the type's axes.
+    s.execute("object.scale", &json!({"sx": 200, "origin": [40, 40]})).unwrap();
+    assert_eq!(s.execute("text.areaOptions", &json!({})).unwrap()["width"].as_f64(), Some(240.0));
+    s.execute("text.areaOptions", &json!({"width": 300})).unwrap();
+    assert_eq!(frame(&s, id), Rect::new(0.0, 0.0, 150.0, 40.0));
+}
+
+#[test]
+fn reshape_area_takes_untrusted_params() {
+    let mut s = session();
+    let id = area(&mut s, 40.0, 40.0, 120.0, 40.0, STORY);
+    let point = id_of(&s.execute("text.create", &json!({"x": 40, "y": 300, "text": "Point"})).unwrap());
+    let rect = id_of(&s.execute("shape.rectangle", &json!({"x": 300, "y": 300, "width": 50, "height": 50})).unwrap());
+    let n = undo_len(&s);
+    for bad in [
+        json!({}),
+        json!({"anchors": [[0, 2]], "dx": 1, "dy": 1}),
+        json!({"id": point.0, "anchors": [[0, 0]], "dx": 1, "dy": 1}),
+        json!({"id": rect.0, "anchors": [[0, 0]], "dx": 1, "dy": 1}),
+        json!({"id": 99_999, "anchors": [[0, 0]], "dx": 1, "dy": 1}),
+        json!({"id": id.0, "dx": 1, "dy": 1}),
+        json!({"id": id.0, "anchors": [], "dx": 1, "dy": 1}),
+        json!({"id": id.0, "anchors": [["a", 1], [0], "x"], "dx": 1, "dy": 1}),
+        json!({"id": id.0, "anchors": [[0, 9]], "dx": 1, "dy": 1}),
+        json!({"id": id.0, "anchors": [[0, 1], [7, 0]], "dx": 1, "dy": 1}),
+        json!({"id": id.0, "anchors": [[0, 2]], "dy": 1}),
+        json!({"id": id.0, "anchors": [[0, 2]], "dx": "far", "dy": 1}),
+        json!({"id": id.0, "anchors": [[0, 2]], "dx": 0, "dy": 1e300}),
+        json!({"id": id.0, "anchors": [[0, 2]], "dx": -1e7, "dy": 0}),
+    ] {
+        assert!(s.execute("text.reshapeArea", &bad).is_err(), "{bad}");
+    }
+    assert_eq!(undo_len(&s), n, "nothing changed");
+    assert_eq!(frame(&s, id), Rect::new(0.0, 0.0, 120.0, 40.0));
+    // Listed twice, an anchor still moves once.
+    s.execute("text.reshapeArea", &json!({"id": id.0, "anchors": [[0, 2], [0, 2]], "dx": 10, "dy": 5})).unwrap();
+    assert_eq!(corners(&s, id)[2], Point::new(130.0, 45.0));
+    assert_eq!(last_step(&s), "Reshape Type Area");
+    // A frame collapsed to nothing lays out (everything overflows) without trouble.
+    for m in [[0.0, 0.0, 0.0, 1.0, 40.0, 0.0], [1.0, 0.0, 0.0, 0.0, 0.0, 40.0], [0.0; 6]] {
+        s.execute("object.transform", &json!({"ids": [id.0], "matrix": m, "typeAreas": true})).unwrap();
+        assert!(layout(&s, id).overflow);
+        s.execute("edit.undo", &json!({})).unwrap();
+    }
+}
+
+#[test]
+fn reshape_area_is_a_registered_command() {
+    let spec = cmd::find_command("text.reshapeArea").unwrap();
+    assert_eq!(spec.label, "Reshape Type Area");
+    assert!(spec.params.contains("anchors") && spec.params.contains("dx"));
+    assert!(cmd::find_command("object.transform").unwrap().params.contains("typeAreas"));
+    assert!(session().commands().iter().any(|c| c.id == "text.reshapeArea" && c.enabled));
+}

crates/engine/src/tests_xform.rs

@@ -148,6 +148,27 @@ fn free_transform_distort_mode_via_pointer() {
     assert_eq!(s.journal.last().map(|j| j.0.as_str()), Some("object.distort"));
 }
 
+#[test]
+fn free_transform_cmd_held_once_a_corner_drag_started_distorts_in_one_step() {
+    let mut s = session();
+    let a = rect(&mut s, 100.0, 100.0, 100.0, 100.0);
+    let v = ViewInfo::default();
+    s.select_tool("freeTransform", v).unwrap();
+    let before = undo_len(&s);
+    let cmd = Mods { cmd: true, ..Default::default() };
+    s.pointer(&PointerEvent::new(PointerKind::Down, 200.0, 200.0), v).unwrap();
+    s.pointer(&PointerEvent::new(PointerKind::Drag, 210.0, 210.0), v).unwrap();
+    s.pointer(&PointerEvent::new(PointerKind::Drag, 250.0, 260.0).with_mods(cmd), v).unwrap();
+    s.pointer(&PointerEvent::new(PointerKind::Up, 250.0, 260.0).with_mods(cmd), v).unwrap();
+    let d = &s.doc().unwrap().doc;
+    let pts: Vec<Point> = d.node(a).unwrap().path_data().unwrap().anchors().map(|(_, _, an)| an.p).collect();
+    for p in [Point::new(250.0, 260.0), Point::new(100.0, 100.0), Point::new(200.0, 100.0), Point::new(100.0, 200.0)] {
+        assert!(pts.iter().any(|q| q.distance(p) < 1e-6), "{p:?} not in {pts:?}");
+    }
+    assert_eq!(undo_len(&s), before + 1);
+    assert_eq!(s.doc().unwrap().history.undo.last().map(|e| e.label.as_str()), Some("Distort"));
+}
+
 #[test]
 fn free_transform_side_handle_scales() {
     let mut s = session();

crates/engine/src/tooling.rs

@@ -214,6 +214,24 @@ impl Session {
         self.tool.wants_text()
     }
 
+    /// IME marked text for the active tool (see `Tool::ime_preedit`; `active_chars` counts
+    /// characters).
+    pub fn tool_preedit(&mut self, text: &str, active_chars: Option<std::ops::Range<usize>>, view: ViewInfo) -> Result<Vec<UiRequest>> {
+        let acts = self.with_tool_cx(view, |t, cx| t.ime_preedit(cx, text, active_chars));
+        self.take_tool_panic()?;
+        self.apply_actions(acts)
+    }
+
+    /// Is the active tool showing uncommitted IME text?
+    pub fn tool_composing(&self) -> bool {
+        self.tool.composing()
+    }
+
+    /// The caret line (document space) the IME candidate window follows.
+    pub fn tool_ime_caret(&mut self, view: ViewInfo) -> Option<(Point, Point)> {
+        self.with_tool_cx(view, |t, cx| t.ime_caret(cx))
+    }
+
     pub fn tool_busy(&self) -> bool {
         self.tool.busy()
     }

crates/engine/tests/import_fuzz.rs

@@ -910,6 +910,9 @@ fn arb_ps_token() -> impl Strategy<Value = String> {
             "stopped", "begin", "end", "dict", "array", "string", "get", "put", "getinterval", "putinterval", "aload", "astore", "forall",
             "[", "]", "<<", ">>", "{", "}", "matrix", "currentmatrix", "setmatrix", "transform", "itransform", "invertmatrix", "pathbbox",
             "clippath", "initclip", "currentpoint", "eexec", "cleartomark", "mark", "counttomark", "showpage", "gstate", "setgstate",
+            "clipsave", "cliprestore", "languagelevel", "cvx", "findresource", "defineresource", "undefineresource", "resourcestatus",
+            "resourceforall", "/Category", "/Generic", "/ProcSet", "(*)", "(G?n*\\\\*?)", "{pop}", "8 string",
+            "(*) {pop} 8 string /Category resourceforall", "/Generic /Category findresource dup length dict copy /Category defineresource",
             "/ASCII85Decode", "/ASCIIHexDecode", "/FlateDecode", "/RunLengthDecode", "/LZWDecode", "/DCTDecode", "/SubFileDecode",
             "/DeviceRGB", "/DeviceCMYK", "/DeviceGray", "/Pattern", "/x", "x", "/Helvetica", "(abc)", "<ff00>", "<~87cURD]i,\"Ebo80~>",
             "true", "false", "null", "[/Separation (S) /DeviceCMYK {dup dup dup}]", "[/Indexed /DeviceRGB 1 <ff000000ff00>]",

crates/eps/src/import/data.rs

@@ -12,7 +12,7 @@ use vectorcraft_geom::Affine;
 use super::graphics::{Space, process};
 use super::interp::{Interp, matrix_of};
 use super::lex::{find, hex_decode};
-use super::obj::{DictRef, Key, Obj, Op, PsError, Res, ps_err};
+use super::obj::{DictRef, Key, Obj, Op, PsError, Res, Shared, ps_err};
 use crate::ps;
 
 /// Most bytes one filter or image reads.
@@ -223,20 +223,15 @@ impl Interp<'_> {
             ReadHexString | ReadString => {
                 let s = self.pop_str()?;
                 let Obj::File(f) = self.pop()? else { return ps_err("typecheck", "") };
-                let n = s.borrow().len();
+                let n = s.len();
                 let got = if op == ReadString { self.read(&f, n)? } else { self.read_hex(&f, n)? };
-                let full = got.len() == n;
-                self.alloc(got.len())?;
-                if let Some(d) = s.borrow_mut().get_mut(..got.len()) {
-                    d.copy_from_slice(&got);
-                }
-                self.push(Obj::string(got))?;
-                self.push(Obj::Bool(full))?;
+                self.fill(s, &got)?;
+                self.push(Obj::Bool(got.len() == n))?;
             }
             ReadLine => {
                 let s = self.pop_str()?;
                 let Obj::File(f) = self.pop()? else { return ps_err("typecheck", "") };
-                let n = s.borrow().len();
+                let n = s.len();
                 let mut line = vec![];
                 let mut ended = false;
                 while line.len() < n {
@@ -252,8 +247,7 @@ impl Interp<'_> {
                         Some(b) => line.push(*b),
                     }
                 }
-                self.alloc(line.len())?;
-                self.push(Obj::string(line))?;
+                self.fill(s, &line)?;
                 self.push(Obj::Bool(ended))?;
             }
             FlushFile | CloseFile => {
@@ -307,12 +301,20 @@ impl Interp<'_> {
         Ok(out)
     }
 
+    /// Read bytes `got` into string `s` and push the part of `s` they fill.
+    fn fill(&mut self, s: Shared<u8>, got: &[u8]) -> Res {
+        if !s.write(0, got) {
+            return ps_err("rangecheck", "");
+        }
+        self.push_interval(Obj::Str(s), 0, got.len())
+    }
+
     /// `filter`: a file that decodes its source. Over the program's own data it decodes when
     /// first read (the data follows the operator that reads it); over other data, at once.
     fn filter(&mut self) -> Res {
         let name = self.pop()?.text().ok_or(PsError::Ps("typecheck", "filter".into()))?;
         let sub = if &*name == "SubFileDecode" {
-            let eod = self.pop_str()?.borrow().clone();
+            let eod = self.pop_str()?.to_vec();
             let count = self.pop_count()?;
             (count, eod)
         } else {
@@ -687,8 +689,8 @@ struct Pixels {
 fn source(o: &Obj) -> Res<Source> {
     Ok(match o {
         Obj::File(f) => Source::File(f.clone()),
-        Obj::Str(s) => Source::Str(s.borrow().clone()),
-        p @ Obj::Array { .. } => Source::Proc(Obj::Array { items: p.items().cloned().unwrap_or_default(), exec: true }),
+        Obj::Str(s) => Source::Str(s.to_vec()),
+        Obj::Array { items, .. } => Source::Proc(Obj::Array { items: items.clone(), exec: true }),
         _ => return ps_err("typecheck", "DataSource"),
     })
 }

crates/eps/src/import/graphics.rs

@@ -106,6 +106,8 @@ pub(crate) struct GState {
     pub cur: Option<Point>,
     pub start: Option<Point>,
     pub clips: Vec<Arc<Clip>>,
+    /// The clips `clipsave` saved, for `cliprestore`.
+    pub saved_clips: Vec<Rc<[Arc<Clip>]>>,
     pub overprint: bool,
     pub font: Option<DictRef>,
 }
@@ -128,6 +130,7 @@ impl Default for GState {
             cur: None,
             start: None,
             clips: vec![],
+            saved_clips: vec![],
             overprint: false,
             font: None,
         }
@@ -489,7 +492,7 @@ impl Interp<'_> {
         let (family, items) = match o {
             Obj::Name(n) | Obj::Exec(n) => (n.clone(), vec![]),
             Obj::Array { items, .. } => {
-                let v = items.borrow().clone();
+                let v = items.to_vec();
                 let n = v.first().and_then(Obj::text).ok_or(PsError::Ps("typecheck", "setcolorspace".into()))?;
                 (n, v)
             }
@@ -702,7 +705,7 @@ impl Interp<'_> {
         let d = match f {
             Obj::Dict(d) => d.clone(),
             Obj::Array { items, .. } => {
-                let fs = items.borrow().clone();
+                let fs = items.to_vec();
                 let mut out = vec![];
                 for g in &fs {
                     out.extend(self.eval(g, t, depth + 1)?.first().copied());
@@ -730,7 +733,7 @@ impl Interp<'_> {
                 Ok(c0.iter().zip(&c1).map(|(a, b)| a + x * (b - a)).collect())
             }
             Some(3.0) => {
-                let fs = get("Functions").and_then(|o| o.items().map(|i| i.borrow().clone())).unwrap_or_default();
+                let fs = get("Functions").and_then(|o| o.items().map(|i| i.to_vec())).unwrap_or_default();
                 let bounds = nums(get("Bounds"));
                 let encode = nums(get("Encode"));
                 let (lo, hi) = (domain.first().copied().unwrap_or(0.0), domain.get(1).copied().unwrap_or(1.0));
@@ -1095,6 +1098,19 @@ impl Interp<'_> {
                 self.g.start = self.g.cur;
             }
             InitClip => self.g.clips.clear(),
+            ClipSave => {
+                if self.g.saved_clips.len() >= MAX_GSAVE {
+                    return Err(PsError::Limit("too many saved clips"));
+                }
+                self.alloc(std::mem::size_of_val(self.g.clips.as_slice()))?;
+                let clips = self.g.clips.as_slice().into();
+                self.g.saved_clips.push(clips);
+            }
+            ClipRestore => {
+                if let Some(clips) = self.g.saved_clips.pop() {
+                    self.g.clips = clips.to_vec();
+                }
+            }
             Clip | EoClip => {
                 let bp = self.g.path.clone();
                 self.clip_with(bp, if op == EoClip { FillRule::EvenOdd } else { FillRule::NonZero });
@@ -1118,7 +1134,7 @@ impl Interp<'_> {
             }
             RectStroke => {
                 let m = match self.stack.last() {
-                    Some(Obj::Array { items, .. }) if items.borrow().len() == 6 => Some(self.pop_matrix()?),
+                    Some(Obj::Array { items, .. }) if items.len() == 6 => Some(self.pop_matrix()?),
                     _ => None,
                 };
                 let mut bp = self.rects()?;
@@ -1157,7 +1173,7 @@ fn linear_points(f: &Obj) -> Option<Vec<f64>> {
     match num("FunctionType")? {
         2.0 if num("N").unwrap_or(1.0) == 1.0 => Some(vec![]),
         3.0 => {
-            let fs = d.get(&Key::name("Functions"))?.items()?.borrow().clone();
+            let fs = d.get(&Key::name("Functions"))?.items()?.to_vec();
             if !fs.iter().all(|g| linear_points(g).is_some_and(|p| p.is_empty())) {
                 return None;
             }

crates/eps/src/import/interp.rs

@@ -11,7 +11,7 @@ use vectorcraft_geom::Affine;
 
 use super::graphics::{GState, Out};
 use super::lex::Lexer;
-use super::obj::{Dict, DictRef, Key, Obj, Op, PsError, Res, ps_err};
+use super::obj::{Dict, DictRef, Key, Obj, Op, PsError, Res, Shared, ps_err};
 
 /// Most operations one file may run.
 const MAX_OPS: u64 = 50_000_000;
@@ -61,6 +61,12 @@ fn encoding() -> Obj {
     Obj::array(vec![Obj::name(".notdef"); 256])
 }
 
+/// The resource categories there are to begin with (instances of `Category`).
+const CATEGORIES: &str = "Category Generic Font CIDFont CMap FontSet Encoding Form Pattern ProcSet ColorSpace Halftone \r
+                          ColorRendering IdiomSet InkParams TrapParams OutputDevice ControlLanguage Localization PDL HWOptions \r
+                          Filter ColorSpaceFamily Emulator IODevice ColorRenderingType FMapType FontType FormType HalftoneType \r
+                          ImageType PatternType FunctionType ShadingType";
+
 impl<'a> Interp<'a> {
     pub fn new(src: &'a [u8], g: GState, out: Out) -> Self {
         let system = new_dict();
@@ -72,7 +78,15 @@ impl<'a> Interp<'a> {
             for name in ["StandardEncoding", "ISOLatin1Encoding"] {
                 d.insert(Key::name(name), encoding());
             }
+            // An integer, as interpreters have it (`systemdict /languagelevel get 2 ge`): run, the
+            // name pushes it all the same.
+            d.insert(Key::name("languagelevel"), Obj::Int(3));
         }
+        // Each category's implementation dictionary (`/Generic /Category findresource`).
+        let categories: Dict =
+            CATEGORIES.split_whitespace().map(|c| (Key::name(c), Obj::dict(Dict::from([(Key::name("Category"), Obj::name(c))])))).collect();
+        let resources = new_dict();
+        resources.borrow_mut().insert(Key::name("Category"), Obj::dict(categories));
         let fonts = new_dict();
         system.borrow_mut().insert(Key::name("FontDirectory"), Obj::Dict(fonts.clone()));
         system.borrow_mut().insert(Key::name("GlobalFontDirectory"), Obj::Dict(fonts.clone()));
@@ -87,7 +101,7 @@ impl<'a> Interp<'a> {
             status: new_dict(),
             error: new_dict(),
             fonts,
-            resources: new_dict(),
+            resources,
             depth: 0,
             ops: 0,
             allocated: 0,
@@ -175,7 +189,7 @@ impl<'a> Interp<'a> {
         }
     }
 
-    pub fn pop_str(&mut self) -> Res<Rc<RefCell<Vec<u8>>>> {
+    pub fn pop_str(&mut self) -> Res<Shared<u8>> {
         match self.pop()? {
             Obj::Str(s) => Ok(s),
             _ => ps_err("typecheck", "a string"),
@@ -183,7 +197,7 @@ impl<'a> Interp<'a> {
     }
 
     /// An array or procedure.
-    pub fn pop_array(&mut self) -> Res<Rc<RefCell<Vec<Obj>>>> {
+    pub fn pop_array(&mut self) -> Res<Shared<Obj>> {
         match self.pop()? {
             Obj::Array { items, .. } => Ok(items),
             _ => ps_err("typecheck", "an array"),
@@ -197,15 +211,9 @@ impl<'a> Interp<'a> {
     }
 
     /// Store `m` into the matrix operand `items` and push it back.
-    pub fn put_matrix(&mut self, items: Rc<RefCell<Vec<Obj>>>, m: Affine) -> Res {
-        {
-            let mut v = items.borrow_mut();
-            if v.len() != 6 {
-                return ps_err("rangecheck", "a matrix");
-            }
-            for (slot, c) in v.iter_mut().zip(m.as_coeffs()) {
-                *slot = Obj::Real(c);
-            }
+    pub fn put_matrix(&mut self, items: Shared<Obj>, m: Affine) -> Res {
+        if items.len() != 6 || !items.write(0, &m.as_coeffs().map(Obj::Real)) {
+            return ps_err("rangecheck", "a matrix");
         }
         self.push(Obj::Array { items, exec: false })
     }
@@ -276,24 +284,24 @@ impl<'a> Interp<'a> {
         Ok(())
     }
 
-    fn run_proc(&mut self, items: &Rc<RefCell<Vec<Obj>>>) -> Res {
+    fn run_proc(&mut self, items: &Shared<Obj>) -> Res {
         self.enter()?;
         let r = self.run_items(items);
         self.depth -= 1;
         r
     }
 
-    fn run_items(&mut self, items: &Rc<RefCell<Vec<Obj>>>) -> Res {
+    fn run_items(&mut self, items: &Shared<Obj>) -> Res {
         let mut i = 0;
         loop {
-            let Some(o) = items.borrow().get(i).cloned() else { return Ok(()) };
+            let Some(o) = items.get(i) else { return Ok(()) };
             i += 1;
             self.exec_token(o)?;
         }
     }
 
     /// Run `proc` as a loop body: `Ok(false)` when it ran `exit`.
-    fn body(&mut self, proc: &Obj) -> Res<bool> {
+    pub fn body(&mut self, proc: &Obj) -> Res<bool> {
         self.tick()?;
         match self.call(proc.clone()) {
             Ok(()) => Ok(true),
@@ -303,7 +311,7 @@ impl<'a> Interp<'a> {
     }
 
     /// Run a procedure operand, executable or not (`exec`, `if`, loops).
-    fn pop_proc(&mut self) -> Res<Obj> {
+    pub fn pop_proc(&mut self) -> Res<Obj> {
         match self.pop()? {
             Obj::Array { items, .. } => Ok(Obj::Array { items, exec: true }),
             o @ (Obj::Op(_) | Obj::Exec(_)) => Ok(o),
@@ -480,7 +488,7 @@ impl<'a> Interp<'a> {
             Gt | Ge | Lt | Le => {
                 let (b, a) = (self.pop()?, self.pop()?);
                 let ord = match (&a, &b) {
-                    (Obj::Str(x), Obj::Str(y)) => x.borrow().as_slice().partial_cmp(y.borrow().as_slice()),
+                    (Obj::Str(x), Obj::Str(y)) => x.borrow().partial_cmp(&*y.borrow()),
                     _ => a.as_num().zip(b.as_num()).and_then(|(x, y)| x.partial_cmp(&y)),
                 }
                 .ok_or(PsError::Ps("typecheck", String::new()))?;
@@ -646,14 +654,10 @@ impl<'a> Interp<'a> {
                 } else {
                     show_text(&self.pop()?)
                 };
-                let n = text.len();
-                if n > s.borrow().len() {
+                if !s.write(0, text.as_bytes()) {
                     return ps_err("rangecheck", "");
                 }
-                if let Some(d) = s.borrow_mut().get_mut(..n) {
-                    d.copy_from_slice(text.as_bytes());
-                }
-                self.push_interval(Obj::Str(s), 0, n)?;
+                self.push_interval(Obj::Str(s), 0, text.len())?;
             }
             ReadOnly | ExecuteOnly | NoAccess | SetPacking | SetGlobal | SetObjectFormat => {
                 if matches!(op, SetPacking | SetGlobal | SetObjectFormat) {
@@ -683,8 +687,8 @@ impl<'a> Interp<'a> {
             }
             Length => {
                 let n = match self.pop()? {
-                    Obj::Array { items, .. } => items.borrow().len(),
-                    Obj::Str(s) => s.borrow().len(),
+                    Obj::Array { items, .. } => items.len(),
+                    Obj::Str(s) => s.len(),
                     Obj::Dict(d) => d.borrow().len(),
                     Obj::Name(n) | Obj::Exec(n) => n.len(),
                     _ => return ps_err("typecheck", ""),
@@ -699,14 +703,8 @@ impl<'a> Interp<'a> {
             Get => {
                 let k = self.pop()?;
                 let o = match self.pop()? {
-                    Obj::Array { items, .. } => {
-                        let i = index(&k)?;
-                        items.borrow().get(i).cloned().ok_or(PsError::Ps("rangecheck", String::new()))?
-                    }
-                    Obj::Str(s) => {
-                        let i = index(&k)?;
-                        Obj::Int(i64::from(*s.borrow().get(i).ok_or(PsError::Ps("rangecheck", String::new()))?))
-                    }
+                    Obj::Array { items, .. } => items.get(index(&k)?).ok_or(PsError::Ps("rangecheck", String::new()))?,
+                    Obj::Str(s) => Obj::Int(i64::from(s.get(index(&k)?).ok_or(PsError::Ps("rangecheck", String::new()))?)),
                     Obj::Dict(d) => {
                         let key = k.key().ok_or(PsError::Ps("typecheck", String::new()))?;
                         let v = d.borrow().get(&key).cloned();
@@ -718,21 +716,21 @@ impl<'a> Interp<'a> {
             }
             Put => {
                 let (v, k, c) = (self.pop()?, self.pop()?, self.pop()?);
-                match c {
-                    Obj::Array { items, .. } => {
-                        let i = index(&k)?;
-                        *items.borrow_mut().get_mut(i).ok_or(PsError::Ps("rangecheck", String::new()))? = v;
-                    }
+                let written = match c {
+                    Obj::Array { items, .. } => items.write(index(&k)?, std::slice::from_ref(&v)),
                     Obj::Str(s) => {
-                        let i = index(&k)?;
                         let b = v.as_num().ok_or(PsError::Ps("typecheck", String::new()))?;
-                        *s.borrow_mut().get_mut(i).ok_or(PsError::Ps("rangecheck", String::new()))? = b as i64 as u8;
+                        s.write(index(&k)?, &[b as i64 as u8])
                     }
                     Obj::Dict(d) => {
                         let key = k.key().ok_or(PsError::Ps("typecheck", String::new()))?;
                         insert(&d, key, v)?;
+                        true
                     }
                     _ => return ps_err("typecheck", ""),
+                };
+                if !written {
+                    return ps_err("rangecheck", "");
                 }
             }
             GetInterval => {
@@ -744,41 +742,35 @@ impl<'a> Interp<'a> {
             PutInterval => {
                 let src = self.pop()?;
                 let at = self.pop_count()?;
-                match (self.pop()?, src) {
-                    (Obj::Array { items, .. }, Obj::Array { items: from, .. }) => {
-                        let from = from.borrow().clone();
-                        let mut v = items.borrow_mut();
-                        let d = v.get_mut(at..at + from.len()).ok_or(PsError::Ps("rangecheck", String::new()))?;
-                        d.clone_from_slice(&from);
-                    }
-                    (Obj::Str(s), Obj::Str(from)) => {
-                        let from = from.borrow().clone();
-                        let mut v = s.borrow_mut();
-                        let d = v.get_mut(at..at + from.len()).ok_or(PsError::Ps("rangecheck", String::new()))?;
-                        d.copy_from_slice(&from);
-                    }
+                let written = match (self.pop()?, src) {
+                    (Obj::Array { items, .. }, Obj::Array { items: from, .. }) => items.write(at, &from.to_vec()),
+                    (Obj::Str(s), Obj::Str(from)) => s.write(at, &from.to_vec()),
                     _ => return ps_err("typecheck", ""),
+                };
+                if !written {
+                    return ps_err("rangecheck", "");
                 }
             }
             Aload => {
                 let items = self.pop_array()?;
-                let all = items.borrow().clone();
-                for o in all {
+                for o in items.to_vec() {
                     self.push(o)?;
                 }
                 self.push(Obj::Array { items, exec: false })?;
             }
             Astore => {
                 let items = self.pop_array()?;
-                let n = items.borrow().len();
-                let at = self.stack.len().checked_sub(n).ok_or(PsError::Ps("stackunderflow", String::new()))?;
-                *items.borrow_mut() = self.stack.split_off(at);
+                let at = self.stack.len().checked_sub(items.len()).ok_or(PsError::Ps("stackunderflow", String::new()))?;
+                if !items.write(0, self.stack.get(at..).unwrap_or_default()) {
+                    return ps_err("rangecheck", "");
+                }
+                self.stack.truncate(at);
                 self.push(Obj::Array { items, exec: false })?;
             }
             Search | AnchorSearch => {
-                let seek = self.pop_str()?.borrow().clone();
+                let seek = self.pop_str()?.to_vec();
                 let s = self.pop_str()?;
-                let text = s.borrow().clone();
+                let text = s.to_vec();
                 let at = if op == Search { super::lex::find(&text, &seek) } else { text.starts_with(&seek).then_some(0) };
                 match at {
                     Some(i) => {
@@ -888,7 +880,6 @@ impl<'a> Interp<'a> {
                     self.push(Obj::Int(v))?;
                 }
             }
-            LanguageLevel => self.push(Obj::Int(3))?,
             Version => self.push(Obj::string(b"3010".to_vec()))?,
             Product => self.push(Obj::string(b"VectorCraft".to_vec()))?,
             RealTime | UserTime => self.push(Obj::Int(0))?,
@@ -922,19 +913,18 @@ impl<'a> Interp<'a> {
                 }
             }
             Obj::Array { items, exec } => {
-                let from = self.pop_array()?.borrow().clone();
-                let n = from.len();
-                {
-                    let mut v = items.borrow_mut();
-                    v.get_mut(..n).ok_or(PsError::Ps("rangecheck", String::new()))?.clone_from_slice(&from);
+                let from = self.pop_array()?.to_vec();
+                if !items.write(0, &from) {
+                    return ps_err("rangecheck", "copy");
                 }
-                self.push_interval(Obj::Array { items, exec }, 0, n)?;
+                self.push_interval(Obj::Array { items, exec }, 0, from.len())?;
             }
             Obj::Str(s) => {
-                let from = self.pop_str()?.borrow().clone();
-                let n = from.len();
-                s.borrow_mut().get_mut(..n).ok_or(PsError::Ps("rangecheck", String::new()))?.copy_from_slice(&from);
-                self.push_interval(Obj::Str(s), 0, n)?;
+                let from = self.pop_str()?.to_vec();
+                if !s.write(0, &from) {
+                    return ps_err("rangecheck", "copy");
+                }
+                self.push_interval(Obj::Str(s), 0, from.len())?;
             }
             Obj::Dict(d) => {
                 let from = self.pop_dict()?.borrow().clone();
@@ -946,16 +936,12 @@ impl<'a> Interp<'a> {
         Ok(())
     }
 
-    /// `n` items of an array or string from `at` (a copy: shared storage isn't modelled).
-    fn push_interval(&mut self, o: Obj, at: usize, n: usize) -> Res {
-        let end = at.checked_add(n).ok_or(PsError::Ps("rangecheck", String::new()))?;
-        self.alloc(n * if matches!(o, Obj::Str(_)) { 1 } else { std::mem::size_of::<Obj>() })?;
+    /// `n` items of an array or string from `at`, sharing its storage.
+    pub fn push_interval(&mut self, o: Obj, at: usize, n: usize) -> Res {
+        let range = || PsError::Ps("rangecheck", String::new());
         let r = match o {
-            Obj::Array { items, exec } => {
-                let v = items.borrow().get(at..end).ok_or(PsError::Ps("rangecheck", String::new()))?.to_vec();
-                Obj::Array { items: Rc::new(RefCell::new(v)), exec }
-            }
-            Obj::Str(s) => Obj::string(s.borrow().get(at..end).ok_or(PsError::Ps("rangecheck", String::new()))?.to_vec()),
+            Obj::Array { items, exec } => Obj::Array { items: items.sub(at, n).ok_or_else(range)?, exec },
+            Obj::Str(s) => Obj::Str(s.sub(at, n).ok_or_else(range)?),
             _ => return ps_err("typecheck", "getinterval"),
         };
         self.push(r)
@@ -966,7 +952,7 @@ impl<'a> Interp<'a> {
         match self.pop()? {
             Obj::Array { items, .. } => {
                 let mut i = 0;
-                while let Some(o) = items.borrow().get(i).cloned() {
+                while let Some(o) = items.get(i) {
                     i += 1;
                     self.push(o)?;
                     if !self.body(&p)? {
@@ -975,8 +961,7 @@ impl<'a> Interp<'a> {
                 }
             }
             Obj::Str(s) => {
-                let bytes = s.borrow().clone();
-                for b in bytes {
+                for b in s.to_vec() {
                     self.push(Obj::Int(i64::from(b)))?;
                     if !self.body(&p)? {
                         break;
@@ -1000,22 +985,19 @@ impl<'a> Interp<'a> {
 
     /// Replace the names in a procedure that stand for operators by the operators, down through
     /// nested procedures.
-    fn bind(&mut self, items: &Rc<RefCell<Vec<Obj>>>, depth: u32) {
+    fn bind(&mut self, items: &Shared<Obj>, depth: u32) {
         if depth > 64 {
             return;
         }
-        let n = items.borrow().len();
-        for i in 0..n {
-            let o = items.borrow().get(i).cloned();
-            match o {
+        for i in 0..items.len() {
+            match items.get(i) {
                 Some(Obj::Exec(name)) => {
-                    if let Some(Obj::Op(op)) = self.lookup(&name)
-                        && let Some(slot) = items.borrow_mut().get_mut(i)
-                    {
-                        *slot = Obj::Op(op);
+                    if let Some(o @ Obj::Op(_)) = self.lookup(&name) {
+                        // `i` is in range and nothing is reading the procedure: the write can't fail.
+                        items.write(i, &[o]);
                     }
                 }
-                Some(Obj::Array { items: inner, exec: true }) if !Rc::ptr_eq(&inner, items) => self.bind(&inner, depth + 1),
+                Some(Obj::Array { items: inner, exec: true }) if !inner.shares(items) => self.bind(&inner, depth + 1),
                 _ => {}
             }
         }
@@ -1032,6 +1014,67 @@ impl<'a> Interp<'a> {
             _ => ps_err("typecheck", ""),
         })
     }
+
+    /// The instances of `category`: `FontDirectory` for fonts.
+    pub fn instances(&mut self, category: &Obj) -> Res<DictRef> {
+        if category.text().as_deref() == Some("Font") { Ok(self.fonts.clone()) } else { self.category(category) }
+    }
+
+    /// `template proc scratch category resourceforall`: `proc` run on each instance name that
+    /// matches `template`, copied into `scratch` (in name order).
+    pub fn resource_for_all(&mut self) -> Res {
+        let category = self.pop()?;
+        let scratch = self.pop_str()?;
+        let p = self.pop_proc()?;
+        let template = self.pop_str()?.to_vec();
+        let mut names: Vec<Vec<u8>> = self.instances(&category)?.borrow().keys().map(|k| show_text(&k.obj()).into_bytes()).collect();
+        names.sort();
+        for name in names {
+            if !self.matches(&template, &name)? {
+                continue;
+            }
+            if !scratch.write(0, &name) {
+                return ps_err("rangecheck", "resourceforall");
+            }
+            self.push_interval(Obj::Str(scratch.clone()), 0, name.len())?;
+            if !self.body(&p)? {
+                break;
+            }
+        }
+        Ok(())
+    }
+
+    /// Does `name` match a `resourceforall` template: `*` any run of bytes, `?` any one, `\` the
+    /// next one as it is? Each step counts as an operation.
+    fn matches(&mut self, template: &[u8], name: &[u8]) -> Res<bool> {
+        let (mut t, mut n) = (0, 0);
+        // Where the last `*` was followed (template, name): a mismatch after it retries from there.
+        let mut star: Option<(usize, usize)> = None;
+        loop {
+            self.tick()?;
+            if n == name.len() {
+                return Ok(template.get(t..).unwrap_or_default().iter().all(|b| *b == b'*'));
+            }
+            let (want, width) = match template.get(t) {
+                Some(b'*') => {
+                    t += 1;
+                    star = Some((t, n));
+                    continue;
+                }
+                Some(b'?') => (name.get(n).copied(), 1),
+                Some(b'\\') => (template.get(t + 1).copied(), 2),
+                c => (c.copied(), 1),
+            };
+            if want.is_some() && want == name.get(n).copied() {
+                (t, n) = (t + width, n + 1);
+                continue;
+            }
+            // The last `*` takes one more byte, else there is no match.
+            let Some((st, sn)) = star else { return Ok(false) };
+            star = Some((st, sn + 1));
+            (t, n) = (st, sn + 1);
+        }
+    }
 }
 
 /// Put `v` under `k` in `d`, within [`MAX_ALLOC`] entries.
@@ -1057,7 +1100,7 @@ fn equal(a: &Obj, b: &Obj) -> bool {
     match (a, b) {
         (Obj::Null, Obj::Null) | (Obj::Mark, Obj::Mark) => true,
         (Obj::Bool(x), Obj::Bool(y)) => x == y,
-        (Obj::Array { items: x, .. }, Obj::Array { items: y, .. }) => Rc::ptr_eq(x, y),
+        (Obj::Array { items: x, .. }, Obj::Array { items: y, .. }) => x.same(y),
         (Obj::Dict(x), Obj::Dict(y)) => Rc::ptr_eq(x, y),
         (Obj::Op(x), Obj::Op(y)) => x == y,
         _ => match (a.as_num(), b.as_num()) {

crates/eps/src/import/mod.rs

@@ -192,7 +192,10 @@ fn finish(mut out: Out) -> Imported {
 
 /// A document of `frame`'s size showing TIFF preview `tiff` stretched over it.
 fn preview(tiff: &[u8], frame: Rect) -> Option<Document> {
-    let img = image::load_from_memory_with_format(tiff, image::ImageFormat::Tiff).ok()?.to_rgba8();
+    let img = match image::load_from_memory_with_format(tiff, image::ImageFormat::Tiff) {
+        Ok(img) => img.to_rgba8(),
+        Err(_) => crate::tiff::palette_rgba(tiff)?,
+    };
     let (w, h) = img.dimensions();
     if w == 0 || h == 0 {
         return None;

crates/eps/src/import/obj.rs

@@ -1,6 +1,6 @@
 //! The PostScript objects the interpreter works with, its operators and its errors.
 
-use std::cell::RefCell;
+use std::cell::{Ref, RefCell};
 use std::collections::HashMap;
 use std::rc::Rc;
 
@@ -31,10 +31,10 @@ pub(crate) enum Obj {
     Name(Rc<str>),
     /// An executable name: looked up and run.
     Exec(Rc<str>),
-    Str(Rc<RefCell<Vec<u8>>>),
+    Str(Shared<u8>),
     /// An array; executable ones are procedures.
     Array {
-        items: Rc<RefCell<Vec<Obj>>>,
+        items: Shared<Obj>,
         exec: bool,
     },
     Dict(DictRef),
@@ -53,15 +53,15 @@ impl Obj {
     }
 
     pub fn string(bytes: Vec<u8>) -> Self {
-        Self::Str(Rc::new(RefCell::new(bytes)))
+        Self::Str(Shared::new(bytes))
     }
 
     pub fn array(items: Vec<Obj>) -> Self {
-        Self::Array { items: Rc::new(RefCell::new(items)), exec: false }
+        Self::Array { items: Shared::new(items), exec: false }
     }
 
     pub fn proc(items: Vec<Obj>) -> Self {
-        Self::Array { items: Rc::new(RefCell::new(items)), exec: true }
+        Self::Array { items: Shared::new(items), exec: true }
     }
 
     pub fn dict(d: Dict) -> Self {
@@ -98,7 +98,7 @@ impl Obj {
     }
 
     /// The items of an array or procedure.
-    pub fn items(&self) -> Option<&Rc<RefCell<Vec<Obj>>>> {
+    pub fn items(&self) -> Option<&Shared<Obj>> {
         match self {
             Self::Array { items, .. } => Some(items),
             _ => None,
@@ -125,6 +125,71 @@ impl Obj {
     }
 }
 
+/// The values of a string or an array: a run of storage that other strings or arrays may share
+/// (`getinterval` makes a new object over part of the same values, as PostScript does).
+#[derive(Clone, Debug)]
+pub(crate) struct Shared<T> {
+    buf: Rc<RefCell<Vec<T>>>,
+    at: usize,
+    len: usize,
+}
+
+impl<T: Clone> Shared<T> {
+    pub fn new(v: Vec<T>) -> Self {
+        Self { len: v.len(), buf: Rc::new(RefCell::new(v)), at: 0 }
+    }
+
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// The values. Only [`Self::write`] borrows the storage mutably, for the copy alone, so this
+    /// never meets it.
+    pub fn borrow(&self) -> Ref<'_, [T]> {
+        let (at, end) = (self.at, self.at.saturating_add(self.len));
+        Ref::map(self.buf.borrow(), |v| v.get(at..end).unwrap_or(&[]))
+    }
+
+    pub fn get(&self, i: usize) -> Option<T> {
+        self.borrow().get(i).cloned()
+    }
+
+    pub fn to_vec(&self) -> Vec<T> {
+        self.borrow().to_vec()
+    }
+
+    /// `n` values from `at`, sharing the storage (`getinterval`); `None` past the end.
+    pub fn sub(&self, at: usize, n: usize) -> Option<Self> {
+        (at.checked_add(n)? <= self.len).then(|| Self { buf: self.buf.clone(), at: self.at + at, len: n })
+    }
+
+    /// Write `vals` from `at`: false when they don't fit (or `vals` is borrowed from the storage).
+    pub fn write(&self, at: usize, vals: &[T]) -> bool {
+        if at.saturating_add(vals.len()) > self.len {
+            return false;
+        }
+        let start = self.at + at;
+        let Ok(mut v) = self.buf.try_borrow_mut() else { return false };
+        match v.get_mut(start..start + vals.len()) {
+            Some(d) => {
+                d.clone_from_slice(vals);
+                true
+            }
+            None => false,
+        }
+    }
+
+    /// The same object (`eq` on arrays): the same values of the same storage.
+    pub fn same(&self, o: &Self) -> bool {
+        Rc::ptr_eq(&self.buf, &o.buf) && self.at == o.at && self.len == o.len
+    }
+
+    /// Do both see the same storage?
+    pub fn shares(&self, o: &Self) -> bool {
+        Rc::ptr_eq(&self.buf, &o.buf)
+    }
+}
+
 impl Key {
     pub fn name(s: &str) -> Self {
         Self::Name(Rc::from(s))
@@ -209,7 +274,7 @@ ops! {
     ErrorDict = "errordict", DollarError = "$error", Bind = "bind",
     // Virtual memory and the environment.
     Save = "save", Restore = "restore", SetGlobal = "setglobal", CurrentGlobal = "currentglobal", VmStatus = "vmstatus",
-    LanguageLevel = "languagelevel", Version = "version", Product = "product", RealTime = "realtime", UserTime = "usertime",
+    Version = "version", Product = "product", RealTime = "realtime", UserTime = "usertime",
     Print = "print", EqPrint = "=", EqEqPrint = "==", Pstack = "pstack", Stack = "stack", Flush = "flush",
     // Graphics state.
     Gsave = "gsave", Grestore = "grestore", GrestoreAll = "grestoreall", InitGraphics = "initgraphics",
@@ -242,8 +307,8 @@ ops! {
     RLineTo = "rlineto", CurveTo = "curveto", RCurveTo = "rcurveto", Arc = "arc", Arcn = "arcn", Arct = "arct",
     Arcto = "arcto", ClosePath = "closepath", FlattenPath = "flattenpath", ReversePath = "reversepath",
     PathBBox = "pathbbox", ClipPath = "clippath", InitClip = "initclip", Clip = "clip", EoClip = "eoclip",
-    RectClip = "rectclip", Fill = "fill", EoFill = "eofill", Stroke = "stroke", RectFill = "rectfill",
-    RectStroke = "rectstroke", ShFill = "shfill",
+    RectClip = "rectclip", ClipSave = "clipsave", ClipRestore = "cliprestore", Fill = "fill", EoFill = "eofill",
+    Stroke = "stroke", RectFill = "rectfill", RectStroke = "rectstroke", ShFill = "shfill",
     // Images.
     Image = "image", ImageMask = "imagemask", ColorImage = "colorimage",
     // Files.
@@ -252,7 +317,8 @@ ops! {
     // Fonts and type.
     FindFont = "findfont", ScaleFont = "scalefont", MakeFont = "makefont", SetFont = "setfont", SelectFont = "selectfont",
     CurrentFont = "currentfont", DefineFont = "definefont", UndefineFont = "undefinefont", FindResource = "findresource",
-    DefineResource = "defineresource", ResourceStatus = "resourcestatus", Show = "show", AShow = "ashow",
+    DefineResource = "defineresource", UndefineResource = "undefineresource", ResourceStatus = "resourcestatus",
+    ResourceForAll = "resourceforall", Show = "show", AShow = "ashow",
     WidthShow = "widthshow", AWidthShow = "awidthshow", XShow = "xshow", YShow = "yshow", XYShow = "xyshow",
     KShow = "kshow", GlyphShow = "glyphshow", StringWidth = "stringwidth", CharPath = "charpath",
     SetCacheDevice = "setcachedevice", SetCharWidth = "setcharwidth",

crates/eps/src/import/tests.rs

@@ -452,3 +452,234 @@ fn device_settings_are_accepted_and_change_nothing() {
     assert_eq!(objects(&r.document).len(), 1, "{:?}", r.warnings);
     assert!(r.warnings.is_empty(), "{:?}", r.warnings);
 }
+
+/// Check that `body` draws one square, blue: it sets blue when what it checks holds, else red.
+fn blue(body: &str) {
+    let r = read(&format!("{body} 10 10 80 80 rectfill"));
+    let o = objects(&r.document);
+    assert_eq!(o.len(), 1, "{body}: {:?}", r.warnings);
+    assert_eq!(fill(&o[0]), Some(&Paint::solid(Color::rgb(0.0, 0.0, 1.0))), "{body}");
+    assert!(r.warnings.is_empty(), "{body}: {:?}", r.warnings);
+}
+
+/// Check that PostScript `cond` leaves `true`.
+fn check(cond: &str) {
+    blue(&format!("{cond} {{ 0 0 1 setrgbcolor }} {{ 1 0 0 setrgbcolor }} ifelse"));
+}
+
+#[test]
+fn the_generic_category_defines_new_categories() {
+    // #234: the reference app's prolog.
+    blue("/Generic /Category findresource pop 0 0 1 setrgbcolor");
+    blue(
+        "[/CSA /Gradient /Procedure] { /Generic /Category findresource dup length dict copy /Category defineresource pop } forall 0 0 1 setrgbcolor",
+    );
+    let define = "[/CSA /Gradient] { /Generic /Category findresource dup length dict copy /Category defineresource pop } forall \
+                  /G1 << /Kind 7 >> /Gradient defineresource pop";
+    check(&format!("{define} /G1 /Gradient findresource /Kind get 7 eq"));
+    check(&format!("{define} /Gradient /Category resourcestatus {{ pop pop true }} {{ false }} ifelse"));
+    check(&format!("{define} /G1 /Gradient resourcestatus {{ pop pop true }} {{ false }} ifelse"));
+    check(&format!("{define} /G1 /Gradient undefineresource /G1 /Gradient resourcestatus not"));
+    check(&format!("{define} {{ /G2 /Gradient findresource }} stopped"));
+    // Unknown categories aren't instances of Category; a category is a dictionary.
+    check("/Nonsense /Category resourcestatus not");
+    check("{ /Nonsense /Category findresource } stopped");
+    check("{ /X 5 /Category defineresource } stopped");
+}
+
+#[test]
+fn clipsave_and_cliprestore_bring_the_clip_back() {
+    // #234.
+    blue("clipsave 0 0 50 50 rectclip cliprestore 0 0 1 setrgbcolor");
+    // The fill after cliprestore covers the whole square, unclipped.
+    let r = read("clipsave 0 0 50 50 rectclip 1 0 0 setrgbcolor 0 0 10 10 rectfill cliprestore 0 0 1 setrgbcolor 10 10 80 80 rectfill");
+    let o = objects(&r.document);
+    assert_eq!(o.len(), 2, "{:?}", r.warnings);
+    assert!(matches!(o[0].kind, NodeKind::Group { clip: true, .. }), "{:?}", o[0].kind);
+    assert!(matches!(o[1].kind, NodeKind::Path { clipping: false, .. }), "{:?}", o[1].kind);
+    assert!(near(bounds(&o[1]), Rect::new(10.0, 10.0, 90.0, 90.0)), "{:?}", bounds(&o[1]));
+    // Nested, leaving the rest of the graphics state alone.
+    let r = read(
+        "0 0 60 60 rectclip clipsave 0 0 20 20 rectclip clipsave 0 0 5 5 rectclip cliprestore 0 1 0 setrgbcolor cliprestore \
+         10 10 80 80 rectfill",
+    );
+    let NodeKind::Group { children, clip: true } = &objects(&r.document)[0].kind else { panic!("{:?}", r.warnings) };
+    assert!(near(bounds(&children[0]), Rect::new(0.0, 40.0, 60.0, 100.0)), "{:?}", bounds(&children[0]));
+    assert_eq!(fill(&children[1]), Some(&Paint::solid(Color::rgb(0.0, 1.0, 0.0))));
+    // grestore undoes the clipsaves after its gsave; cliprestore with nothing saved does nothing.
+    let o = objects(&read("cliprestore gsave clipsave 0 0 50 50 rectclip grestore cliprestore 10 10 80 80 rectfill").document);
+    assert!(matches!(o[0].kind, NodeKind::Path { .. }), "{:?}", o[0].kind);
+}
+
+#[test]
+fn languagelevel_is_an_integer_and_runs() {
+    // #234.
+    blue(
+        "/Level2? systemdict /languagelevel known dup { pop systemdict /languagelevel get 2 ge } if def \
+         Level2? { 0 0 1 setrgbcolor } { 1 0 0 setrgbcolor } ifelse",
+    );
+    check("languagelevel 3 eq");
+    check("{ languagelevel } bind exec 3 eq");
+}
+
+#[test]
+fn intervals_share_their_arrays_and_strings() {
+    // #234: astore into a subarray stores into the array.
+    blue("/a 4 array def 1 2 a 0 2 getinterval astore pop a 0 get 1 eq { 0 0 1 setrgbcolor } { 1 0 0 setrgbcolor } ifelse");
+    // put, putinterval and copy into an interval; an interval of an interval.
+    check("/a [0 0 0 0 0] def a 1 3 getinterval 1 2 getinterval 0 7 put a 2 get 7 eq");
+    check("/a [0 0 0 0] def a 2 2 getinterval 0 [8 9] putinterval a 3 get 9 eq");
+    check("/a [0 0 0 0] def [5 6] a 1 2 getinterval copy pop a 2 get 6 eq");
+    check("/s (abcd) def s 1 2 getinterval 0 (XY) putinterval s (aXYd) eq");
+    check("/s (abcd) def s 2 1 getinterval 0 90 put s (abZd) eq");
+    check("/s 8 string def 42 s 2 6 getinterval cvs pop s 2 2 getinterval (42) eq");
+    // The same interval is the same object; another one is not.
+    check("/a 4 array def a 0 2 getinterval a 0 2 getinterval eq");
+    check("/a 4 array def a 0 2 getinterval a 0 3 getinterval ne a 0 2 getinterval a 1 2 getinterval ne and");
+    // Reads and writes stay inside the interval.
+    check("/a [1 2 3 4] def { a 1 2 getinterval 2 get } stopped { a 1 2 getinterval 2 0 put } stopped and");
+    check("/a [1 2 3 4] def a 1 2 getinterval length 2 eq a 1 2 getinterval aload pop 3 eq exch 2 eq and and");
+    check("/n 0 def [1 2 3 4] 1 2 getinterval { n add /n exch def } forall n 5 eq");
+    // A procedure from an interval runs only its part.
+    check("{ 1 2 3 } 1 2 getinterval cvx exec add 5 eq");
+    // The prolog's stack save: the operands into part of one array, and back.
+    check(
+        "/stk 10 array def /lev 3 array def 1 2 3 count dup lev exch 0 exch put stk exch 0 exch getinterval astore pop \
+         clear stk 0 lev 0 get getinterval aload pop add add 6 eq",
+    );
+}
+
+#[test]
+fn resourceforall_enumerates_matching_names() {
+    // #234.
+    blue("(*) { pop } 128 string /Category resourceforall 0 0 1 setrgbcolor");
+    let count = |template: &str| format!("/n 0 def ({template}) {{ pop /n n 1 add def }} 128 string /ProcSet resourceforall n");
+    let define = "[/Foo /Fop /Bar /F*x] { 1 dict /ProcSet defineresource pop } forall";
+    check(&format!("{define} {} 4 eq", count("*")));
+    check(&format!("{define} {} 2 eq", count("Fo?")));
+    check(&format!("{define} {} 3 eq", count("F*")));
+    check(&format!("{define} {} 1 eq", count("F\\\\*x")));
+    check(&format!("{define} {} 0 eq", count("Q*")));
+    check(&format!("{define} {} 1 eq", count("*a*")));
+    // Each name is copied into the scratch string; exit stops.
+    check(&format!("{define} /last () def (B*) {{ dup length string copy /last exch def }} 8 string /ProcSet resourceforall last (Bar) eq"));
+    check(&format!("{define} /n 0 def (*) {{ pop /n n 1 add def exit }} 8 string /ProcSet resourceforall n 1 eq"));
+    // A scratch string too small for the names, as the prolog probes it.
+    check(&format!("{define} {{ (*) {{ pop }} 2 string /ProcSet resourceforall }} stopped"));
+    check("/n 0 def (Gen*) { pop /n n 1 add def } 16 string /Category resourceforall n 1 eq");
+}
+
+/// A `w` × `h` 8-bit palette TIFF with an alpha sample (`ExtraSamples` [1]), uncompressed in
+/// strips of `per` rows, in either byte order, as the reference app writes its EPS previews:
+/// pixel (x, y) is entry `(x + y) % 3` of a red, green, blue map, at alpha `12 x`.
+fn palette_tiff(w: u16, h: u16, per: u16, big: bool) -> Vec<u8> {
+    let u16b = |v: u16| if big { v.to_be_bytes() } else { v.to_le_bytes() };
+    let u32b = |v: u32| if big { v.to_be_bytes() } else { v.to_le_bytes() };
+    // Shorts in an entry, left-justified.
+    let shorts = |v: &[u16]| -> [u8; 4] {
+        let mut f = [0; 4];
+        for (i, s) in v.iter().enumerate() {
+            f[2 * i..2 * i + 2].copy_from_slice(&u16b(*s));
+        }
+        f
+    };
+    let row = u32::from(w) * 2;
+    let mut out = vec![];
+    out.extend(if big { *b"MM\0*" } else { *b"II*\0" });
+    out.extend([0; 4]);
+    let data_at = out.len() as u32;
+    for y in 0..h {
+        for x in 0..w {
+            out.extend([((x + y) % 3) as u8, (x * 12) as u8]);
+        }
+    }
+    let map_at = out.len() as u32;
+    for (c, full) in [0xFFFF, 0x8000, 0xFFFF].into_iter().enumerate() {
+        for i in 0..256 {
+            out.extend(u16b(if i == c { full } else { 0 }));
+        }
+    }
+    let strips: Vec<u16> = (0..h.div_ceil(per)).collect();
+    let offsets_at = out.len() as u32;
+    for k in &strips {
+        out.extend(u32b(data_at + u32::from(k * per) * row));
+    }
+    let counts_at = out.len() as u32;
+    for k in &strips {
+        out.extend(u32b(u32::from(per.min(h - k * per)) * row));
+    }
+    let ifd = out.len() as u32;
+    out[4..8].copy_from_slice(&u32b(ifd));
+    let n = strips.len() as u32;
+    let entries: [(u16, u16, u32, [u8; 4]); 12] = [
+        (256, 3, 1, shorts(&[w])),
+        (257, 3, 1, shorts(&[h])),
+        (258, 3, 2, shorts(&[8, 8])),
+        (259, 3, 1, shorts(&[1])),
+        (262, 3, 1, shorts(&[3])),
+        (273, 4, n, u32b(if n == 1 { data_at } else { offsets_at })),
+        (277, 3, 1, shorts(&[2])),
+        (278, 3, 1, shorts(&[per])),
+        (279, 4, n, u32b(if n == 1 { u32::from(h) * row } else { counts_at })),
+        (284, 3, 1, shorts(&[1])),
+        (320, 3, 768, u32b(map_at)),
+        (338, 3, 1, shorts(&[1])),
+    ];
+    out.extend(u16b(entries.len() as u16));
+    for (tag, kind, count, field) in entries {
+        out.extend(u16b(tag));
+        out.extend(u16b(kind));
+        out.extend(u32b(count));
+        out.extend(field);
+    }
+    out.extend([0; 4]);
+    out
+}
+
+#[test]
+fn a_palette_preview_with_alpha_is_placed() {
+    // #234: the program fails, so the preview is placed.
+    let ps = eps("0 0 1 setrgbcolor 10 10 80 80 rectfill frobnicate");
+    for (big, per) in [(false, 5), (true, 5), (false, 10), (true, 3)] {
+        let tiff = palette_tiff(20, 10, per, big);
+        let r = import(&crate::dos_eps(&ps, &tiff).unwrap()).unwrap();
+        assert!(r.preview, "{big} {per}");
+        assert!(r.warnings[0].contains("preview"), "{:?}", r.warnings);
+        let o = objects(&r.document);
+        let NodeKind::Image(im) = &o[0].kind else { panic!("{:?}", o[0].kind) };
+        assert_eq!((im.width, im.height), (20, 10));
+        assert!(near(bounds(&o[0]), Rect::new(0.0, 0.0, 100.0, 100.0)));
+        let png = image::load_from_memory(&r.document.images[&im.key].bytes).unwrap().to_rgba8();
+        for (x, y) in [(0, 0), (1, 0), (2, 0), (19, 9), (7, 4), (3, 6)] {
+            let [r, g, b] = [[255, 0, 0], [0, 128, 0], [0, 0, 255]][((x + y) % 3) as usize];
+            assert_eq!(png.get_pixel(x, y).0, [r, g, b, (x * 12) as u8], "({x}, {y}) {big} {per}");
+        }
+    }
+}
+
+#[test]
+fn a_damaged_palette_preview_is_refused_without_panicking() {
+    let tiff = palette_tiff(20, 10, 5, false);
+    assert!(crate::tiff::palette_rgba(&tiff).is_some());
+    // Cut anywhere before the last entry's value (the directory is at the end): nothing.
+    for cut in 0..tiff.len() - 6 {
+        assert!(crate::tiff::palette_rgba(&tiff[..cut]).is_none(), "{cut}");
+    }
+    // Any byte changed: a picture or nothing.
+    for big in [false, true] {
+        let tiff = palette_tiff(20, 10, 5, big);
+        for at in 0..tiff.len() {
+            for v in [0, 1, 2, 0x7f, 0x80, 0xff] {
+                let mut t = tiff.clone();
+                t[at] = v;
+                let _ = crate::tiff::palette_rgba(&t);
+            }
+        }
+    }
+    // A damaged preview of an unreadable program: the hard error.
+    let ps = eps("frobnicate");
+    for t in [&tiff[..tiff.len() / 2], b"II*\0garbage", &[0; 64]] {
+        let e = import(&crate::dos_eps(&ps, t).unwrap()).unwrap_err();
+        assert!(e.contains("can't be read"), "{e}");
+    }
+}

crates/eps/src/import/text.rs

@@ -110,38 +110,46 @@ impl Interp<'_> {
                 let category = self.pop()?;
                 let v = self.pop()?;
                 let k = self.pop()?.key().ok_or(PsError::Ps("typecheck", "defineresource".into()))?;
-                let dict = if category.text().as_deref() == Some("Font") { self.fonts.clone() } else { self.category(&category)? };
-                dict.borrow_mut().insert(k, v.clone());
+                // A category is defined by its implementation dictionary.
+                if category.text().as_deref() == Some("Category") && !matches!(v, Obj::Dict(_)) {
+                    return ps_err("typecheck", "defineresource");
+                }
+                self.instances(&category)?.borrow_mut().insert(k, v.clone());
                 self.push(v)?;
             }
+            UndefineResource => {
+                let category = self.pop()?;
+                let k = self.pop()?.key().ok_or(PsError::Ps("typecheck", "undefineresource".into()))?;
+                self.instances(&category)?.borrow_mut().remove(&k);
+            }
             ResourceStatus => {
                 let category = self.pop()?;
                 let k = self.pop()?.key().ok_or(PsError::Ps("typecheck", "resourcestatus".into()))?;
-                let dict = if category.text().as_deref() == Some("Font") { self.fonts.clone() } else { self.category(&category)? };
-                let known = dict.borrow().contains_key(&k);
+                let known = self.instances(&category)?.borrow().contains_key(&k);
                 if known {
                     self.push(Obj::Int(1))?;
                     self.push(Obj::Int(0))?;
                 }
                 self.push(Obj::Bool(known))?;
             }
+            ResourceForAll => self.resource_for_all()?,
             Show => {
-                let s = self.pop_str()?.borrow().clone();
+                let s = self.pop_str()?.to_vec();
                 self.show(&s)?;
             }
             AShow => {
-                let s = self.pop_str()?.borrow().clone();
+                let s = self.pop_str()?.to_vec();
                 self.nums::<2>()?;
                 self.show(&s)?;
             }
             WidthShow => {
-                let s = self.pop_str()?.borrow().clone();
+                let s = self.pop_str()?.to_vec();
                 self.pop()?;
                 self.nums::<2>()?;
                 self.show(&s)?;
             }
             AWidthShow => {
-                let s = self.pop_str()?.borrow().clone();
+                let s = self.pop_str()?.to_vec();
                 self.nums::<2>()?;
                 self.pop()?;
                 self.nums::<2>()?;
@@ -149,11 +157,11 @@ impl Interp<'_> {
             }
             XShow | YShow | XYShow => {
                 self.pop()?;
-                let s = self.pop_str()?.borrow().clone();
+                let s = self.pop_str()?.to_vec();
                 self.show(&s)?;
             }
             KShow => {
-                let s = self.pop_str()?.borrow().clone();
+                let s = self.pop_str()?.to_vec();
                 self.pop()?;
                 self.show(&s)?;
             }
@@ -163,14 +171,14 @@ impl Interp<'_> {
                 self.show(ch.encode_utf8(&mut [0; 4]).as_bytes())?;
             }
             StringWidth => {
-                let s = self.pop_str()?.borrow().clone();
+                let s = self.pop_str()?.to_vec();
                 let (_, _, v) = self.set_type(&s, Point::ZERO)?;
                 self.push_num(v.x)?;
                 self.push_num(v.y)?;
             }
             CharPath => {
                 self.pop_bool()?;
-                let s = self.pop_str()?.borrow().clone();
+                let s = self.pop_str()?.to_vec();
                 self.char_path(&s)?;
             }
             SetCacheDevice => {

crates/eps/src/tiff.rs

@@ -1,5 +1,6 @@
 //! The TIFF preview (little-endian, PackBits strips, written by the raster exports' TIFF writer):
-//! 1-bit black and white, or 8-bit RGB with or without an alpha channel. Also the PNG thumbnail.
+//! 1-bit black and white, or 8-bit RGB with or without an alpha channel. Also the PNG thumbnail,
+//! and a reader for the palette previews other apps write that the `image` crate can't decode.
 
 use std::borrow::Cow;
 
@@ -50,3 +51,111 @@ pub(crate) fn png(img: &Raster) -> Result<Vec<u8>, String> {
     rgba.write_to(&mut std::io::Cursor::new(&mut out), image::ImageFormat::Png).map_err(|e| e.to_string())?;
     Ok(out)
 }
+
+/// Most pixels a palette preview may have.
+const MAX_PIXELS: usize = 1 << 26;
+/// Most values a TIFF field may have.
+const MAX_VALUES: usize = 1 << 20;
+
+/// A TIFF's bytes in its byte order.
+struct Tiff<'a> {
+    b: &'a [u8],
+    big: bool,
+}
+
+impl Tiff<'_> {
+    fn u16(&self, at: usize) -> Option<u16> {
+        let b: [u8; 2] = self.b.get(at..at.checked_add(2)?)?.try_into().ok()?;
+        Some(if self.big { u16::from_be_bytes(b) } else { u16::from_le_bytes(b) })
+    }
+
+    fn u32(&self, at: usize) -> Option<u32> {
+        let b: [u8; 4] = self.b.get(at..at.checked_add(4)?)?.try_into().ok()?;
+        Some(if self.big { u32::from_be_bytes(b) } else { u32::from_le_bytes(b) })
+    }
+
+    /// The values of the directory entry at `at` (bytes, shorts or longs; in the entry when they
+    /// fit in four bytes).
+    fn values(&self, at: usize) -> Option<Vec<u32>> {
+        let (kind, n) = (self.u16(at.checked_add(2)?)?, self.u32(at.checked_add(4)?)? as usize);
+        let size = match kind {
+            1 => 1,
+            3 => 2,
+            4 => 4,
+            _ => return None,
+        };
+        if n > MAX_VALUES {
+            return None;
+        }
+        let field = at.checked_add(8)?;
+        let start = if n * size <= 4 { field } else { self.u32(field)? as usize };
+        (0..n)
+            .map(|i| {
+                let at = start.checked_add(i * size)?;
+                match size {
+                    1 => self.b.get(at).map(|v| u32::from(*v)),
+                    2 => self.u16(at).map(u32::from),
+                    _ => self.u32(at),
+                }
+            })
+            .collect()
+    }
+}
+
+/// An 8-bit palette TIFF, with or without an alpha sample (`ExtraSamples`), uncompressed and
+/// interleaved, as RGBA: the layout of other apps' EPS previews. `None` for anything else.
+pub(crate) fn palette_rgba(bytes: &[u8]) -> Option<image::RgbaImage> {
+    let big = match bytes.get(..4)? {
+        b"II*\0" => false,
+        b"MM\0*" => true,
+        _ => return None,
+    };
+    let t = Tiff { b: bytes, big };
+    let ifd = t.u32(4)? as usize;
+    let entries = usize::from(t.u16(ifd)?);
+    let mut fields = std::collections::HashMap::new();
+    for i in 0..entries {
+        let at = ifd.checked_add(2 + i * 12)?;
+        fields.insert(t.u16(at)?, at);
+    }
+    let get = |tag: u16| fields.get(&tag).and_then(|at| t.values(*at));
+    let one = |tag: u16| get(tag).and_then(|v| v.first().copied());
+    let (w, h) = (one(256)? as usize, one(257)? as usize);
+    let samples = one(277).unwrap_or(1) as usize;
+    let alpha = samples == 2 && matches!(get(338)?.as_slice(), [0..=2]);
+    let plain = one(259).unwrap_or(1) == 1 && one(262)? == 3 && one(284).unwrap_or(1) == 1;
+    if !plain || !(samples == 1 || alpha) || get(258)?.iter().any(|b| *b != 8) || w == 0 || h == 0 || w.checked_mul(h)? > MAX_PIXELS {
+        return None;
+    }
+    let map = get(320)?;
+    if map.len() != 3 * 256 {
+        return None;
+    }
+    // Strips of `per` rows each, in order.
+    let (offsets, counts) = (get(273)?, get(279)?);
+    let per = (one(278).unwrap_or(u32::MAX) as usize).min(h);
+    let row = w * samples;
+    // The strips are in the file: so is all that's allocated.
+    if per == 0 || offsets.len() != counts.len() || offsets.len() < h.div_ceil(per) || row * h > bytes.len() {
+        return None;
+    }
+    let mut data = Vec::with_capacity(row * h);
+    for (k, (at, n)) in offsets.iter().zip(&counts).take(h.div_ceil(per)).enumerate() {
+        let want = per.min(h - k * per) * row;
+        if (*n as usize) < want {
+            return None;
+        }
+        let at = *at as usize;
+        data.extend_from_slice(bytes.get(at..at.checked_add(want)?)?);
+    }
+    // Map entries are 16-bit.
+    let channel = |c: usize, i: usize| map.get(c * 256 + i).map_or(0, |v| ((u64::from(*v).min(65_535) * 255 + 32_767) / 65_535) as u8);
+    let rgba = data
+        .chunks_exact(samples)
+        .flat_map(|px| {
+            let i = usize::from(px.first().copied().unwrap_or(0));
+            [channel(0, i), channel(1, i), channel(2, i), px.get(1).copied().unwrap_or(255)]
+        })
+        .collect();
+    image::RgbaImage::from_raw(w as u32, h as u32, rgba)
+}

crates/mcp/src/lib.rs

@@ -16,11 +16,16 @@
 
 mod backend;
 mod headless;
+pub mod logging;
+mod prompts;
+mod resources;
 mod server;
 mod tools;
 
 pub use backend::{Backend, Remote};
 pub use headless::Headless;
+pub use prompts::{PROMPTS, PromptArg, PromptDef};
+pub use resources::{DOC_JSON_URI, DOC_URI, TEMPLATES};
 pub use server::{PROTOCOL_VERSION, Server};
 pub use tools::{ToolResult, call_tool, tool_definitions};
 
@@ -48,4 +53,6 @@ mod tests_persp;
 #[cfg(test)]
 mod tests_place;
 #[cfg(test)]
+mod tests_protocol;
+#[cfg(test)]
 mod tests_svg;

crates/mcp/src/logging.rs

@@ -0,0 +1,220 @@
+//! `logging/setLevel` and the `notifications/message` it turns on.
+//!
+//! VectorCraft's crates log through the `log` facade, and until now nothing installed a logger, so
+//! every `log::debug!` went nowhere. This module is the sink for them: a `log` logger that turns
+//! records into MCP `notifications/message`, filtered to the level the client asked for.
+//!
+//! The **binary** owns the choice of logger and calls [`install`]; the library never does. A
+//! library that installed a process-wide logger and set the max level would silence whatever
+//! logger an embedder had already set up, without being asked — so `Server::new` only forwards a
+//! `logging/setLevel` the client explicitly sent.
+//!
+//! Nothing is sent before the client asks for it, because MCP has no business pushing log lines at
+//! a client that never asked.
+
+use std::sync::Mutex;
+use std::sync::atomic::{AtomicU8, Ordering};
+
+use log::{Level, LevelFilter};
+use serde_json::{Value, json};
+
+/// The severity from the last `logging/setLevel`, as an index into [`LEVELS`]; [`OFF`] means silent.
+static LEVEL: AtomicU8 = AtomicU8::new(OFF);
+
+/// The stored value that means "no logging".
+const OFF: u8 = u8::MAX;
+
+/// Records waiting to be drained into the next `notifications/message` batch.
+static QUEUE: Mutex<Vec<Value>> = Mutex::new(Vec::new());
+
+/// RFC 5424 severities, from the least to the most severe, as the spec orders them.
+const LEVELS: [&str; 8] = ["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"];
+
+/// The severity a `logging/setLevel` level names, and the `log` level it filters at. `None` for
+/// anything the spec doesn't name.
+///
+/// Four of the eight severities collapse onto `log`'s Error, so the index is kept as well: a
+/// client that asked for `emergency` must be able to hear that it is `emergency`, not `error`.
+fn parse(name: &str) -> Option<(u8, Level)> {
+    let level = match name {
+        "debug" => Level::Debug,
+        "info" | "notice" => Level::Info,
+        "warning" => Level::Warn,
+        "error" | "critical" | "alert" | "emergency" => Level::Error,
+        _ => return None,
+    };
+    Some((LEVELS.iter().position(|l| *l == name)? as u8, level))
+}
+
+/// The severity name a `log` record is reported under.
+fn severity(level: Level) -> &'static str {
+    match level {
+        Level::Trace | Level::Debug => "debug",
+        Level::Info => "info",
+        Level::Warn => "warning",
+        Level::Error => "error",
+    }
+}
+
+/// A `logging/setLevel` level the spec does not name. Nothing was changed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct UnknownLevel;
+
+/// Turn logging on at `level`, or off with `None`.
+///
+/// `Err(UnknownLevel)` means the name is not one the spec uses and nothing changed; a rejected
+/// level must leave the accepted one in place rather than silencing logging entirely.
+pub fn set_level(level: Option<&str>) -> Result<(), UnknownLevel> {
+    let Some(name) = level else {
+        LEVEL.store(OFF, Ordering::Relaxed);
+        log::set_max_level(LevelFilter::Off);
+        clear();
+        return Ok(());
+    };
+    let Some((index, parsed)) = parse(name) else { return Err(UnknownLevel) };
+    LEVEL.store(index, Ordering::Relaxed);
+    log::set_max_level(parsed.to_level_filter());
+    // Records already queued at the old level are dropped rather than leaked at the new one.
+    clear();
+    Ok(())
+}
+
+/// The level currently requested, if any.
+pub fn level() -> Option<&'static str> {
+    let index = LEVEL.load(Ordering::Relaxed);
+    if index == OFF {
+        return None;
+    }
+    LEVELS.get(usize::from(index)).copied()
+}
+
+/// Take the queued records, so the server can send them as `notifications/message`.
+pub fn drain() -> Vec<Value> {
+    match QUEUE.lock() {
+        Ok(mut q) => std::mem::take(&mut *q),
+        // A poisoned lock only means some other thread panicked while logging; the records in it
+        // are still readable and worth sending.
+        Err(poisoned) => std::mem::take(&mut *poisoned.into_inner()),
+    }
+}
+
+/// Forget whatever is queued (used when the client stops listening).
+pub fn clear() {
+    if let Ok(mut q) = QUEUE.lock() {
+        q.clear();
+    }
+}
+
+/// The `log` logger that feeds [`QUEUE`].
+struct Sink;
+
+impl log::Log for Sink {
+    fn enabled(&self, metadata: &log::Metadata) -> bool {
+        LEVEL.load(Ordering::Relaxed) != OFF && metadata.level() <= log::max_level()
+    }
+
+    fn log(&self, record: &log::Record) {
+        if !self.enabled(record.metadata()) {
+            return;
+        }
+        let message = json!({
+            "level": severity(record.level()),
+            "logger": record.target(),
+            "data": record.args().to_string(),
+        });
+        // A full queue means the client is not draining; drop rather than grow without bound.
+        if let Ok(mut q) = QUEUE.lock()
+            && q.len() < MAX_QUEUED
+        {
+            q.push(message);
+        }
+    }
+
+    fn flush(&self) {}
+}
+
+/// Records kept while the client is behind.
+const MAX_QUEUED: usize = 512;
+
+static SINK: Sink = Sink;
+
+/// Install the sink once per process. The binary calls this; the library does not.
+///
+/// Later calls are ignored: the second `Server` in a test run finds it already there, which is
+/// exactly what it wants.
+pub fn install() {
+    // `set_logger` fails only when a logger is already installed; keeping the first one is correct.
+    let _already_installed = log::set_logger(&SINK);
+    // Silent until a client sends `logging/setLevel`, so an embedder that installs this sink for
+    // its own reasons gets no records it did not ask for.
+    log::set_max_level(LevelFilter::Off);
+}
+
+/// The level and the queue are process-wide, so the tests that move them take turns. The server
+/// itself is one thread, so nothing else has to.
+#[cfg(test)]
+pub(crate) fn test_turn() -> std::sync::MutexGuard<'static, ()> {
+    match TEST_LOCK.lock() {
+        Ok(guard) => guard,
+        Err(poisoned) => poisoned.into_inner(),
+    }
+}
+
+#[cfg(test)]
+static TEST_LOCK: Mutex<()> = Mutex::new(());
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn levels_round_trip_and_reject_nonsense() {
+        let _turn = test_turn();
+        install();
+        assert_eq!(set_level(Some("warning")), Ok(()));
+        assert_eq!(level(), Some("warning"));
+        assert_eq!(set_level(Some("nope")), Err(UnknownLevel), "an unknown level changes nothing");
+        assert_eq!(level(), Some("warning"), "the old level survives a bad request");
+        assert_eq!(set_level(Some("emergency")), Ok(()));
+        assert_eq!(level(), Some("emergency"));
+        assert_eq!(set_level(None), Ok(()));
+        assert_eq!(level(), None);
+    }
+
+    #[test]
+    fn every_spec_level_is_understood() {
+        let _turn = test_turn();
+        install();
+        for name in LEVELS {
+            assert_eq!(set_level(Some(name)), Ok(()), "{name}");
+            assert_eq!(level(), Some(name), "{name}");
+        }
+        set_level(None).ok();
+    }
+
+    #[test]
+    fn records_appear_as_messages_only_when_asked_for() {
+        let _turn = test_turn();
+        install();
+        set_level(None).ok();
+        clear();
+        log::error!("before logging was enabled");
+        assert!(drain().is_empty(), "silent until set_level");
+
+        set_level(Some("info")).ok();
+        clear();
+        log::warn!("hello {name}", name = "world");
+        // Another test thread may log while logging is on, so look for ours rather than counting.
+        let got = drain();
+        let ours = got.iter().find(|m| m["data"] == "hello world").unwrap_or_else(|| panic!("not in {got:?}"));
+        assert_eq!(ours["level"], "warning");
+        assert!(ours["logger"].as_str().unwrap_or_default().starts_with("vectorcraft_mcp"), "{ours}");
+
+        // Below the requested level stays out.
+        set_level(Some("error")).ok();
+        clear();
+        log::info!("too chatty");
+        assert!(drain().is_empty());
+        set_level(None).ok();
+    }
+}

crates/mcp/src/prompts.rs

@@ -0,0 +1,558 @@
+//! MCP prompts (`prompts/list`, `prompts/get`) and `completion/complete`.
+//!
+//! A prompt is a reusable VectorCraft workflow: `prompts/get` hands the model one templated user
+//! message, so a client can offer "make a poster" the way it offers a slash command. Every prompt's
+//! arguments double as completion sources, and the resource templates in [`crate::resources`] share
+//! the same [`Live`] catalogues, so `completion/complete` can suggest real command ids, effect ids,
+//! swatch names and export formats instead of a fixed list that goes stale.
+
+use serde_json::{Value, json};
+use vectorcraft_engine::cmd::fileio::FORMATS;
+
+use crate::backend::Backend;
+
+/// How many values one `completion/complete` reply may carry (the spec's maximum).
+const MAX_VALUES: usize = 100;
+
+/// A catalogue the completion values are read from, so they follow the app instead of a copy.
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum Live {
+    /// Export formats the engine writes (`document.formats`).
+    Formats,
+    /// Image Trace preset names (`imageTrace.presets`).
+    TracePresets,
+    /// Live effect ids (`effect.list`).
+    Effects,
+    /// Every command id (`engine.commands`).
+    Commands,
+    /// Swatch and colour-group names in the document (`swatch.list`).
+    Swatches,
+    /// Layer and object ids in the active document (`document.inspect`).
+    Objects,
+}
+
+/// Where one prompt argument's suggestions come from.
+#[derive(Clone, Copy)]
+pub enum Values {
+    /// A fixed list, written out here.
+    Fixed(&'static [&'static str]),
+    /// The live catalogue.
+    Live(Live),
+}
+
+impl Values {
+    fn resolve(&self, b: &mut dyn Backend) -> Vec<String> {
+        match self {
+            Values::Fixed(v) => v.iter().map(|s| (*s).to_string()).collect(),
+            Values::Live(live) => live_values(b, *live),
+        }
+    }
+}
+
+/// The values of one live catalogue, read fresh so a suggestion is never stale.
+pub(crate) fn live_values(b: &mut dyn Backend, live: Live) -> Vec<String> {
+    match live {
+        Live::Formats => FORMATS.iter().filter(|f| f.write).map(|f| f.id.to_string()).collect(),
+        Live::TracePresets => names(b, "imageTrace.presets", Some("presets")),
+        Live::Effects => names(b, "effect.list", Some("catalog")),
+        // The command catalogue is a control method, not an engine command.
+        Live::Commands => b.call("engine.commands", json!({})).map(|v| ids_in(&v, None)).unwrap_or_default(),
+        Live::Swatches => names(b, "swatch.list", Some("swatches")),
+        Live::Objects => object_ids(b),
+    }
+}
+
+/// The `id` or `name` of every entry a query command returns, optionally under one key.
+///
+/// These are engine commands, so they go through `engine.execute`; that reaches the same commands
+/// in both backends, where a control method the headless session doesn't implement would not.
+fn names(b: &mut dyn Backend, command: &str, key: Option<&str>) -> Vec<String> {
+    b.call("engine.execute", json!({"command": command, "params": {}})).map(|v| ids_in(&v, key)).unwrap_or_default()
+}
+
+fn ids_in(reply: &Value, key: Option<&str>) -> Vec<String> {
+    let items = match key {
+        Some(k) => reply.get(k).and_then(Value::as_array).map_or(&[][..], Vec::as_slice),
+        None => reply.as_array().map_or(&[][..], Vec::as_slice),
+    };
+    // Catalogs are small, but never trust a document that grew one.
+    items.iter().take(MAX_VALUES * 8).filter_map(|i| i.get("id").or_else(|| i.get("name"))).filter_map(Value::as_str).map(str::to_string).collect()
+}
+
+/// Ids of every layer and object in the active document, for `vectorcraft://object/{id}`.
+fn object_ids(b: &mut dyn Backend) -> Vec<String> {
+    let mut out = Vec::new();
+    let Ok(v) = b.call("document.inspect", json!({})) else { return out };
+    let Some(layers) = v.get("layers").and_then(Value::as_array) else { return out };
+    let mut stack: Vec<&Value> = layers.iter().rev().collect();
+    while let Some(node) = stack.pop() {
+        if let Some(id) = node.get("id").and_then(Value::as_i64) {
+            out.push(id.to_string());
+        }
+        if let Some(kids) = node.get("children").and_then(Value::as_array) {
+            stack.extend(kids.iter().rev());
+        }
+    }
+    out
+}
+
+/// One prompt argument.
+pub struct PromptArg {
+    pub name: &'static str,
+    pub description: &'static str,
+    pub required: bool,
+    /// Substituted for `{name}` when the caller leaves the argument out.
+    pub default: &'static str,
+    pub values: Values,
+}
+
+/// One prompt: a workflow with templated arguments.
+pub struct PromptDef {
+    pub name: &'static str,
+    pub title: &'static str,
+    pub description: &'static str,
+    pub arguments: &'static [PromptArg],
+    /// The message body; every `{argument}` is replaced with its value.
+    pub text: &'static str,
+}
+
+/// Recolour methods (`recolor.apply`'s `method`), written here because they are a closed set.
+const RECOLOR_METHODS: &[&str] = &["exact", "preserveTints", "scaleTints", "tintsShades", "hueShift"];
+
+static NONE: &[&str] = &[];
+
+/// Every prompt, in `prompts/list` order.
+pub static PROMPTS: &[PromptDef] = &[
+    PromptDef {
+        name: "poster",
+        title: "Design a poster",
+        description: "Lay out a poster from a brief: live shapes, gradients, type and live effects, checked with screenshots before export.",
+        arguments: &[
+            PromptArg {
+                name: "brief",
+                description: "What the poster is for, and the words it must carry",
+                required: true,
+                default: "",
+                values: Values::Fixed(NONE),
+            },
+            PromptArg {
+                name: "palette",
+                description: "The colours to use, or how to choose them",
+                required: false,
+                default: "a limited scheme of three to five colours taken from the brief",
+                values: Values::Fixed(&[
+                    "a limited scheme of three to five colours taken from the brief",
+                    "a monochrome scheme in one hue, varying value and opacity",
+                    "a two-colour complementary scheme",
+                    "an analogous scheme across neighbouring hues",
+                ]),
+            },
+            PromptArg {
+                name: "text",
+                description: "The exact headline and supporting lines to set",
+                required: false,
+                default: "invent short, concrete wording that fits the brief",
+                values: Values::Fixed(NONE),
+            },
+        ],
+        text: "\
+Design a poster in VectorCraft.
+
+Brief: {brief}
+Palette: {palette}
+Wording: {text}
+
+Coordinates are points in document space: y points down and the origin is the first
+artboard's top-left. Work in the document that is already open (inspect_document); only
+run file.new when the brief asks for a different artboard size.
+
+Method:
+1. Plan the layout before drawing — a hierarchy of shapes, then the type on top.
+2. draw_shape for geometry (rectangle with `radius` for corners, ellipse, polygon, star,
+   line); draw_path for anything with curves, from `points` or from SVG `d`.
+3. set_paint for colour. A fill may be \"#rrggbb\", [r,g,b], {c,m,y,k}, {gray} or a whole
+   paint.setFill params object — pass {\"gradient\": {…}} for a gradient.
+4. add_text for type: point type at (x, y), area type with width and height, or mode
+   \"area\"/\"onPath\" to flow it in or along a path.
+5. apply_effect for live effects; call it with no `effect` first to get the catalogue with
+   each effect's parameters and defaults.
+6. screenshot to look at what you made, fix what is wrong, and only then export.
+
+Keep it editable: live shapes, live effects and live text. Do not flatten and do not
+rasterise unless the brief asks for it.",
+    },
+    PromptDef {
+        name: "icon-set",
+        title: "Draw an icon set",
+        description: "Build a row of consistent icons as live vector shapes on a grid, then check them as a set.",
+        arguments: &[
+            PromptArg { name: "subject", description: "What the icons depict", required: true, default: "", values: Values::Fixed(NONE) },
+            PromptArg {
+                name: "count",
+                description: "How many icons in the set",
+                required: false,
+                default: "6",
+                values: Values::Fixed(&["4", "6", "8", "12", "16"]),
+            },
+            PromptArg {
+                name: "detail",
+                description: "How detailed each icon should be",
+                required: false,
+                default: "a single flat silhouette, no strokes",
+                values: Values::Fixed(&[
+                    "a single flat silhouette, no strokes",
+                    "a filled silhouette with a stroke around it",
+                    "an outlined shape with its strokes only",
+                    "two-tone: a filled shape and a smaller accent shape",
+                ]),
+            },
+        ],
+        text: "\
+Draw a set of {count} icons of {subject} in VectorCraft, {detail}.
+
+Coordinates are points in document space (y down, origin at the first artboard's
+top-left).
+
+Method:
+1. Decide the cell size and the gap first, then lay every icon into its own cell so the set
+   reads as one family: the same stroke weight, the same optical size, the same corner radius.
+2. Build each icon from draw_shape and draw_path — live shapes, not strokes traced from
+   somewhere else. Use `points` with `in`/`out` handles for the curves a silhouette needs.
+3. set_paint the whole set the same way, then break one colour out on the object that needs
+   the accent.
+4. screenshot the set and judge it as a set: equal weight, aligned baselines, consistent
+   padding. Fix what looks off rather than adding more detail.
+
+Return the ids of the icons in a grid, and leave them as separate objects on one layer.",
+    },
+    PromptDef {
+        name: "recolor",
+        title: "Recolour artwork",
+        description: "Recolour the selection with explicit rows, or cluster its colours first with recolor.colors.",
+        arguments: &[
+            PromptArg {
+                name: "palette",
+                description: "The colours to map onto, or 'cluster' to group similar colours first",
+                required: true,
+                default: "",
+                values: Values::Fixed(&[
+                    "cluster",
+                    "a monochrome ramp from light to dark",
+                    "a complementary two-colour scheme",
+                    "one hue per layer, keeping the original values",
+                ]),
+            },
+            PromptArg {
+                name: "method",
+                description: "How a row's colours take their new colour (recolor.apply's own default is exact; scaleTints suits a recolour driven from recolor.reduce)",
+                required: false,
+                default: "exact",
+                values: Values::Fixed(RECOLOR_METHODS),
+            },
+        ],
+        text: "\
+Recolour the current selection in VectorCraft with {palette}, using the `{method}` recolour method.
+
+Method:
+1. inspect_document to see what is selected and what colours it actually uses.
+2. If you do not know the colours, run recolor.colors first: it groups similar colours into
+   rows (k-means in Lab, weighted by use) and hands back the map. Then edit the `to` colour of
+   each row and apply it. That is the reliable route for artwork you did not draw.
+3. If you know the colours, run recolor.apply directly with `map`: one row per source colour,
+   `from` as keys or \"#rrggbb\", `to` as a colour. Each new colour keeps the model of the one it
+   replaces, and gradients, meshes, text and pattern tiles follow.
+4. Group the colours with `group` so the result stays editable, and use `limitTo` to snap new
+   colours to a swatch library.
+5. screenshot to check the result against the original intent.
+
+One undo step covers the whole change; gradients and linked swatches stay linked.",
+    },
+    PromptDef {
+        name: "trace-and-style",
+        title: "Trace an image and style it",
+        description: "Trace a placed raster with Image Trace, then apply a live effect and paint over the result.",
+        arguments: &[
+            PromptArg { name: "path", description: "Path to the image file", required: true, default: "", values: Values::Fixed(NONE) },
+            PromptArg {
+                name: "preset",
+                description: "Image Trace preset to start from",
+                required: false,
+                default: "Default",
+                values: Values::Live(Live::TracePresets),
+            },
+            PromptArg {
+                name: "effect",
+                description: "A live effect to apply to the traced shapes",
+                required: false,
+                default: "stylize.scribble",
+                values: Values::Live(Live::Effects),
+            },
+        ],
+        text: "\
+Trace the image at {path} in VectorCraft with the \"{preset}\" preset, then style the result
+with the {effect} effect.
+
+Method:
+1. open_file the image: it becomes a document of its own pixel size.
+2. imageTrace.make with the preset name, adjusting `params` — mode blackAndWhite, grayscale or
+   color, then threshold, colors, paths, corners, noise, method abutting or overlapping,
+   ignoreWhite, snapCurvesToLines. Run imageTrace.presets to see every preset with its numbers.
+   Lower paths and higher corners give the clean, logo-like result; high fidelity needs paths
+   near 90.
+3. apply_effect {effect} on the traced shapes. Call apply_effect with no `effect` for the
+   catalogue and each effect's parameters.
+4. set_paint over the traced shapes to give the artwork its own colours.
+5. screenshot, then remove the placed image if it is still underneath.
+
+The trace is real geometry: every traced shape stays selectable and editable.",
+    },
+    PromptDef {
+        name: "export-set",
+        title: "Export an artboard set",
+        description: "Export every artboard in several formats at once, with per-format options, and report what each one lost.",
+        arguments: &[
+            PromptArg {
+                name: "formats",
+                description: "Formats to write, in order",
+                required: false,
+                default: "svg, pdf, png",
+                values: Values::Live(Live::Formats),
+            },
+            PromptArg {
+                name: "directory",
+                description: "Where the files go",
+                required: false,
+                default: "the current directory",
+                values: Values::Fixed(NONE),
+            },
+            PromptArg {
+                name: "scale",
+                description: "Raster scale in pixels per point (raster formats only)",
+                required: false,
+                default: "2",
+                values: Values::Fixed(&["1", "2", "3", "4"]),
+            },
+        ],
+        text: "\
+Export the document in VectorCraft to {formats}, into {directory}, at {scale} pixels per
+point for the raster formats.
+
+Method:
+1. document.formats lists every format the engine reads and writes, with each one's options and
+   their defaults. Read it before exporting so the options you pass are real ones.
+2. export once per format. A path's extension picks the format; `options` carries the rest, for
+   example {\"quality\": 80} for jpg. pdf writes one page per artboard — all of them, or
+   `artboard` (0-based) / `range` (\"1-3, 5\", 1-based); the other formats write one artboard.
+3. export without a path to get the bytes back as dataBase64 instead of a file.
+4. Report the `warnings` each export returns: they name what that format cannot carry.
+
+Live effects are kept on export (geometry baked; shadows, glows and blur become SVG filters),
+and text stays text unless you pass outlineText.",
+    },
+];
+
+/// The message body as a client should receive it.
+///
+/// Our source wraps these texts at the column limit, which would leave line breaks in the middle
+/// of a sentence — and a substituted argument landing on one of them. So each source line is
+/// folded into the paragraph it belongs to, while list items keep a line of their own.
+fn flow(text: &str) -> String {
+    text.split("\n\n")
+        .map(|paragraph| {
+            let mut out = String::new();
+            for line in paragraph.lines().map(str::trim).filter(|l| !l.is_empty()) {
+                if !out.is_empty() {
+                    out.push(if is_item(line) { '\n' } else { ' ' });
+                }
+                out.push_str(line);
+            }
+            out
+        })
+        .collect::<Vec<_>>()
+        .join("\n\n")
+}
+
+/// A numbered or dashed list item, which starts a line instead of continuing one.
+fn is_item(line: &str) -> bool {
+    if let Some(body) = line.strip_prefix("- ") {
+        return !body.is_empty();
+    }
+    line.split_once(". ").is_some_and(|(number, _)| !number.is_empty() && number.len() <= 3 && number.chars().all(|c| c.is_ascii_digit()))
+}
+
+/// `prompts/list`.
+pub fn list() -> Value {
+    let prompts: Vec<Value> = PROMPTS
+        .iter()
+        .map(|p| {
+            let arguments: Vec<Value> =
+                p.arguments.iter().map(|a| json!({"name": a.name, "description": a.description, "required": a.required})).collect();
+            json!({"name": p.name, "title": p.title, "description": p.description, "arguments": arguments})
+        })
+        .collect();
+    json!({ "prompts": prompts })
+}
+
+/// `prompts/get`: the prompt's messages with `{argument}` filled in.
+pub fn get(name: &str, args: &Value) -> Result<Value, String> {
+    let Some(p) = PROMPTS.iter().find(|p| p.name == name) else {
+        let ids: Vec<&str> = PROMPTS.iter().map(|p| p.name).collect();
+        return Err(format!("unknown prompt `{name}` ({})", ids.join("|")));
+    };
+    let mut text = flow(p.text);
+    for a in p.arguments {
+        let given = args.get(a.name).filter(|v| !v.is_null()).map(|v| match v {
+            Value::String(s) => s.clone(),
+            other => other.to_string(),
+        });
+        let value = match given {
+            Some(v) if !v.is_empty() => v,
+            _ if a.required => return Err(format!("prompt `{name}` needs the `{a_name}` argument", a_name = a.name)),
+            _ => a.default.to_string(),
+        };
+        text = text.replace(&format!("{{{}}}", a.name), &value);
+    }
+    Ok(json!({
+        "description": p.description,
+        "messages": [{"role": "user", "content": {"type": "text", "text": text}}],
+    }))
+}
+
+/// `completion/complete`: values for a prompt argument or a resource-template variable.
+///
+/// Unknown references and unknown argument names come back empty rather than as an error: a
+/// completion is a convenience, and the caller is usually mid-typing.
+pub fn complete(b: &mut dyn Backend, params: &Value) -> Value {
+    let empty = json!({"completion": {"values": [], "total": 0, "hasMore": false}});
+    let Some(reference) = params.get("ref") else { return empty };
+    let typed = params.get("argument").and_then(|a| a.get("value")).and_then(Value::as_str).unwrap_or("");
+    let name = params.get("argument").and_then(|a| a.get("name")).and_then(Value::as_str).unwrap_or("");
+
+    let values = match reference.get("type").and_then(Value::as_str) {
+        Some("ref/prompt") => match reference.get("name").and_then(Value::as_str).and_then(|n| PROMPTS.iter().find(|p| p.name == n)) {
+            Some(p) => match p.arguments.iter().find(|a| a.name == name) {
+                Some(a) => a.values.resolve(b),
+                None => Vec::new(),
+            },
+            None => Vec::new(),
+        },
+        Some("ref/resource") => match reference.get("uri").and_then(Value::as_str).map(crate::resources::template_source) {
+            Some((_, Some(live))) => live_values(b, live),
+            _ => Vec::new(),
+        },
+        _ => Vec::new(),
+    };
+
+    // Rank by prefix first (what the user is typing), then by substring.
+    let needle = typed.to_lowercase();
+    let mut matches: Vec<String> = values.iter().filter(|v| v.to_lowercase().starts_with(&needle)).cloned().collect();
+    if matches.is_empty() && !needle.is_empty() {
+        matches = values.iter().filter(|v| v.to_lowercase().contains(&needle)).cloned().collect();
+    }
+    let total = matches.len();
+    let has_more = total > MAX_VALUES;
+    matches.truncate(MAX_VALUES);
+    json!({"completion": {"values": matches, "total": total, "hasMore": has_more}})
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn b() -> Box<dyn Backend> {
+        Box::new(crate::Headless::with_document())
+    }
+
+    #[test]
+    fn every_prompt_lists_and_renders() {
+        let listed = list();
+        let entries = listed["prompts"].as_array().expect("prompts");
+        assert_eq!(entries.len(), PROMPTS.len());
+        for (p, entry) in PROMPTS.iter().zip(entries) {
+            assert!(!p.name.is_empty() && !p.text.is_empty(), "{}", p.name);
+            assert_eq!(entry["name"], p.name);
+            assert_eq!(entry["description"], p.description);
+            // Arguments are advertised with the names prompts/get will accept.
+            let names: Vec<&str> = p.arguments.iter().map(|a| a.name).collect();
+            let listed: Vec<String> =
+                entry["arguments"].as_array().map_or(Vec::new(), |a| a.iter().filter_map(|x| x["name"].as_str().map(str::to_string)).collect());
+            let names: Vec<String> = names.into_iter().map(str::to_string).collect();
+            assert_eq!(names, listed, "{}: listed arguments", p.name);
+
+            // Every required argument supplied: the prompt renders.
+            let args: Value = json!(p.arguments.iter().filter(|a| a.required).map(|a| (a.name, "x")).collect::<std::collections::BTreeMap<_, _>>());
+            let v = get(p.name, &args).unwrap_or_else(|e| panic!("{} renders: {e}", p.name));
+            assert_eq!(v["messages"].as_array().map(Vec::len), Some(1));
+            assert_eq!(v["messages"][0]["role"], "user");
+            let text = v["messages"][0]["content"]["text"].as_str().unwrap_or_default();
+            assert!(text.len() > 200, "{}: too short", p.name);
+            // Templating left nothing behind, and the source's line wrapping is gone.
+            // Only a declared argument's braces are placeholders; JSON examples carry braces too.
+            for a in p.arguments {
+                assert!(!text.contains(&format!("{{{}}}", a.name)), "{}: `{}` left in place", p.name, a.name);
+            }
+            assert!(!text.contains('\n') || text.contains("\n\n") || p.arguments.is_empty(), "{}: stray line break", p.name);
+            assert!(!text.contains("  "), "{}: double space", p.name);
+
+            // Only a missing required argument may stop it.
+            let missing: Value = json!({});
+            assert_eq!(get(p.name, &missing).is_err(), p.arguments.iter().any(|a| a.required), "{}", p.name);
+        }
+    }
+
+    #[test]
+    fn flow_keeps_paragraphs_and_list_items() {
+        let flowed = flow("first line\nsecond line\n\nnew paragraph\n1. one\n2. two\n- bullet");
+        assert_eq!(flowed, "first line second line\n\nnew paragraph\n1. one\n2. two\n- bullet");
+        assert_eq!(flow(""), "");
+        assert_eq!(flow("no breaks"), "no breaks");
+    }
+
+    #[test]
+    fn prompt_arguments_are_filled_in() {
+        let v = get("export-set", &json!({"formats": "pdf, tiff", "scale": "4"})).unwrap();
+        let text = v["messages"][0]["content"]["text"].as_str().unwrap_or_default();
+        assert!(text.contains("pdf, tiff"), "{text}");
+        assert!(text.contains("4 pixels per point"), "{text}");
+    }
+
+    #[test]
+    fn unknown_prompt_and_missing_argument_are_errors() {
+        assert!(get("nope", &json!({})).is_err());
+        let e = get("poster", &json!({"brief": ""})).unwrap_err();
+        assert!(e.contains("brief"), "{e}");
+    }
+
+    #[test]
+    fn completions_rank_prefix_first_and_cap_at_100() {
+        let mut b = b();
+        let v = complete(
+            b.as_mut(),
+            &json!({"ref": {"type": "ref/prompt", "name": "trace-and-style"}, "argument": {"name": "preset", "value": "photo"}}),
+        );
+        let values = v["completion"]["values"].as_array().unwrap();
+        assert!(!values.is_empty(), "imageTrace.presets should answer: {v}");
+        assert!(values.iter().all(|x| x.as_str().unwrap_or_default().to_lowercase().contains("photo")), "{v}");
+
+        // A nonsense prefix falls back to substring matches, and never exceeds 100.
+        let v = complete(b.as_mut(), &json!({"ref": {"type": "ref/prompt", "name": "export-set"}, "argument": {"name": "formats", "value": ""}}));
+        let all = v["completion"]["values"].as_array().unwrap().len();
+        assert!(all > 3, "formats should answer: {v}");
+        assert!(v["completion"]["total"].as_u64().unwrap() >= all as u64);
+    }
+
+    #[test]
+    fn unknown_completion_targets_are_empty_not_errors() {
+        let mut b = b();
+        for params in [
+            json!({"ref": {"type": "ref/prompt", "name": "nope"}, "argument": {"name": "x", "value": ""}}),
+            json!({"ref": {"type": "ref/prompt", "name": "poster"}, "argument": {"name": "nope", "value": ""}}),
+            json!({"ref": {"type": "ref/resource", "uri": "vectorcraft://nope/{id}"}, "argument": {"name": "id", "value": ""}}),
+            json!({"ref": {"type": "ref/other"}, "argument": {"name": "x", "value": ""}}),
+            json!({}),
+        ] {
+            let v = complete(b.as_mut(), &params);
+            assert_eq!(v["completion"]["values"], json!([]), "{params}");
+        }
+    }
+}

crates/mcp/src/resources.rs

@@ -0,0 +1,265 @@
+//! MCP resources: the fixed documents, the templates an agent can address parts of the
+//! document by, and reading either.
+//!
+//! The templates matter for long sessions. `vectorcraft://document/json` returns the whole model,
+//! which on a real document is thousands of lines an agent pays for again on every change; the
+//! templates hand out one object, one command definition or one effect's parameters instead, and
+//! they are what `completion/complete` suggests ids and names from.
+
+use serde_json::{Value, json};
+
+use crate::backend::Backend;
+use crate::prompts::Live;
+
+/// The active document's summary: artboards, layer tree, selection, history.
+pub const DOC_URI: &str = "vectorcraft://document";
+/// The whole document model as JSON.
+pub const DOC_JSON_URI: &str = "vectorcraft://document/json";
+
+/// Why a resource could not be read. The distinction matters: the server turns it into `-32002`
+/// (no such resource) or `-32602` (bad URI), and guessing from the message text would not hold.
+#[derive(Debug)]
+pub enum ReadError {
+    /// The URI names no resource or template this server serves.
+    NotFound(String),
+    /// The template has no value, or the value names nothing.
+    Invalid(String),
+    /// The backend could not be asked at all.
+    Backend(String),
+}
+
+/// One addressable template: the URI with `{var}`, and what its variable can be.
+pub struct Template {
+    pub uri: &'static str,
+    pub name: &'static str,
+    pub title: &'static str,
+    pub description: &'static str,
+    pub mime: &'static str,
+    pub live: Live,
+}
+
+/// Every template, in `resources/templates/list` order.
+pub static TEMPLATES: &[Template] = &[
+    Template {
+        uri: "vectorcraft://object/{id}",
+        name: "object",
+        title: "One layer or object",
+        description: "The layer or object with this id, with its children, bounds and paint (document.inspect)",
+        mime: "application/json",
+        live: Live::Objects,
+    },
+    Template {
+        uri: "vectorcraft://command/{id}",
+        name: "command",
+        title: "One command",
+        description: "The command with this id: label, menu path, shortcut, parameter description and whether it is enabled now (engine.commands)",
+        mime: "application/json",
+        live: Live::Commands,
+    },
+    Template {
+        uri: "vectorcraft://effect/{id}",
+        name: "effect",
+        title: "One live effect",
+        description: "The live effect with this id and its parameters with their defaults (effect.list)",
+        mime: "application/json",
+        live: Live::Effects,
+    },
+    Template {
+        uri: "vectorcraft://swatch/{name}",
+        name: "swatch",
+        title: "One swatch",
+        description: "The swatch or gradient/pattern swatch with this name (swatch.list)",
+        mime: "application/json",
+        live: Live::Swatches,
+    },
+];
+
+/// `resources/list`.
+pub fn list() -> Value {
+    json!({"resources": [
+        {"uri": DOC_URI, "name": "document", "title": "Active document (summary)", "description": "Layer tree, artboards, selection and history of the active document (document.inspect)", "mimeType": "application/json"},
+        {"uri": DOC_JSON_URI, "name": "document-json", "title": "Active document (full model)", "description": "The complete document model as JSON (document.json)", "mimeType": "application/json"},
+    ]})
+}
+
+/// `resources/templates/list`.
+pub fn templates() -> Value {
+    let list: Vec<Value> = TEMPLATES
+        .iter()
+        .map(|t| json!({"uriTemplate": t.uri, "name": t.name, "title": t.title, "description": t.description, "mimeType": t.mime}))
+        .collect();
+    json!({ "resourceTemplates": list })
+}
+
+/// Which template a URI is an instance of, and what its variable can be.
+pub fn template_source(uri: &str) -> (&str, Option<Live>) {
+    for t in TEMPLATES {
+        let Some((prefix, _)) = t.uri.split_once('{') else { continue };
+        if uri.starts_with(prefix) {
+            return (t.uri, Some(t.live));
+        }
+    }
+    (uri, None)
+}
+
+/// `resources/read`: the document behind a resource URI.
+pub fn read(b: &mut dyn Backend, uri: &str) -> Result<Value, ReadError> {
+    if uri == DOC_URI {
+        return b.call("document.inspect", json!({})).map_err(ReadError::Backend);
+    }
+    if uri == DOC_JSON_URI {
+        return exec(b, "document.json").map_err(ReadError::Backend);
+    }
+    let (template, var) = match TEMPLATES.iter().find(|t| template_source(uri).0 == t.uri) {
+        Some(t) => (t, variable(uri, t.uri)),
+        None => return Err(ReadError::NotFound(uri.to_string())),
+    };
+    if var.is_empty() {
+        return Err(ReadError::Invalid(format!("{} needs a value for `{}`", template.uri, variable_name(template.uri))));
+    }
+    let found = match template.name {
+        "object" => find_object(b, &var).map_err(ReadError::Backend)?,
+        // The command catalogue is a control method; the rest are engine commands.
+        "command" => find_in(b.call("engine.commands", json!({})).map_err(ReadError::Backend)?, None, "id", &var),
+        "effect" => find_in(exec(b, "effect.list").map_err(ReadError::Backend)?, Some("catalog"), "id", &var),
+        "swatch" => find_in(exec(b, "swatch.list").map_err(ReadError::Backend)?, Some("swatches"), "name", &var),
+        other => return Err(ReadError::NotFound(format!("no reader for template `{other}`"))),
+    };
+    Ok(match found {
+        Some(v) => v,
+        None => return Err(ReadError::Invalid(format!("no {} named `{var}` in the active document", template.name))),
+    })
+}
+
+/// Run a query engine command. That reaches both backends, where a control method the headless
+/// session doesn't implement would not.
+fn exec(b: &mut dyn Backend, command: &str) -> Result<Value, String> {
+    b.call("engine.execute", json!({"command": command, "params": {}}))
+}
+
+/// The part of a URI between the template's `{` and its `}`.
+fn variable(uri: &str, template: &str) -> String {
+    let Some(open) = template.find('{') else { return String::new() };
+    let prefix = &template[..open];
+    let rest = uri.strip_prefix(prefix).unwrap_or("");
+    let raw = rest.split('}').next().unwrap_or("");
+    decode(raw)
+}
+
+/// The variable's name, e.g. `id` or `name`.
+fn variable_name(template: &str) -> &str {
+    template.split_once('{').and_then(|(_, r)| r.split_once('}')).map_or("", |(n, _)| n)
+}
+
+/// Percent-decoding, so a swatch called "Brand 40%" can be addressed as `Brand%2040%25`.
+fn decode(s: &str) -> String {
+    let bytes = s.as_bytes();
+    let mut out = Vec::with_capacity(bytes.len());
+    let mut i = 0;
+    while let Some(b) = bytes.get(i).copied() {
+        if b == b'%'
+            && i + 2 < bytes.len()
+            && let Ok(byte) = u8::from_str_radix(s.get(i + 1..i + 3).unwrap_or(""), 16)
+        {
+            out.push(byte);
+            i += 3;
+            continue;
+        }
+        out.push(b);
+        i += 1;
+    }
+    String::from_utf8_lossy(&out).into_owned()
+}
+
+/// The layer or object with this id in the active document, with its subtree.
+fn find_object(b: &mut dyn Backend, id: &str) -> Result<Option<Value>, String> {
+    let doc = exec(b, "document.inspect")?;
+    Ok(find_node(doc.get("layers"), id))
+}
+
+/// Depth-first search of the layer tree for a node whose `id` matches.
+fn find_node(node: Option<&Value>, id: &str) -> Option<Value> {
+    let nodes = node?.as_array()?;
+    let mut stack: Vec<&Value> = nodes.iter().rev().collect();
+    while let Some(n) = stack.pop() {
+        let hit = match n.get("id") {
+            Some(Value::String(s)) => s == id,
+            Some(Value::Number(number)) => number.to_string() == id,
+            _ => false,
+        };
+        if hit {
+            return Some(n.clone());
+        }
+        if let Some(kids) = n.get("children").and_then(Value::as_array) {
+            stack.extend(kids.iter().rev());
+        }
+    }
+    None
+}
+
+/// The item in a query command's array whose `field` equals `value`.
+fn find_in(reply: Value, key: Option<&str>, field: &str, value: &str) -> Option<Value> {
+    let items = match key {
+        Some(k) => reply.get(k).and_then(Value::as_array).map_or(&[][..], Vec::as_slice),
+        None => reply.as_array().map_or(&[][..], Vec::as_slice),
+    };
+    items.iter().take(MAX_CATALOGUE).find(|i| i.get(field).and_then(Value::as_str) == Some(value)).cloned()
+}
+
+/// Catalogs come from the app, but never trust one that grew without bound.
+const MAX_CATALOGUE: usize = 20_000;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn variables_are_split_out_and_decoded() {
+        assert_eq!(variable("vectorcraft://object/42", "vectorcraft://object/{id}"), "42");
+        assert_eq!(variable("vectorcraft://swatch/Brand%2040%25", "vectorcraft://swatch/{name}"), "Brand 40%");
+        assert_eq!(variable("vectorcraft://swatch/a%zzb", "vectorcraft://swatch/{name}"), "a%zzb");
+        assert_eq!(variable("vectorcraft://other", "vectorcraft://object/{id}"), "");
+        assert_eq!(variable_name("vectorcraft://swatch/{name}"), "name");
+        assert_eq!(variable_name("no template"), "");
+    }
+
+    #[test]
+    fn templates_are_addressable() {
+        assert_eq!(template_source("vectorcraft://object/7"), ("vectorcraft://object/{id}", Some(Live::Objects)));
+        assert_eq!(template_source("vectorcraft://command/paint.setFill").1, Some(Live::Commands));
+        assert_eq!(template_source("vectorcraft://document").1, None);
+    }
+
+    #[test]
+    fn lists_are_well_formed() {
+        let l = list();
+        assert_eq!(l["resources"].as_array().map(Vec::len), Some(2));
+        let t = templates();
+        let items = t["resourceTemplates"].as_array().expect("templates");
+        assert_eq!(items.len(), TEMPLATES.len());
+        for (entry, t) in items.iter().zip(TEMPLATES) {
+            assert_eq!(entry["uriTemplate"], t.uri);
+            assert!(t.uri.contains('{'), "{} has no variable", t.uri);
+            assert!(t.description.len() > 20, "{} needs a description", t.name);
+        }
+    }
+
+    #[test]
+    fn missing_and_unknown_uris_are_errors() {
+        let mut b = Box::new(crate::Headless::with_document());
+        assert!(read(b.as_mut(), "vectorcraft://nope").is_err());
+        assert!(read(b.as_mut(), "vectorcraft://object/").is_err());
+        assert!(read(b.as_mut(), "vectorcraft://object/99999").is_err());
+        assert!(read(b.as_mut(), DOC_URI).is_ok());
+    }
+
+    #[test]
+    fn an_object_is_readable_once_it_exists() {
+        let mut b = Box::new(crate::Headless::with_document());
+        let made = b.call("engine.execute", json!({"command": "shape.rectangle", "params": {"x": 10, "y": 10, "width": 50, "height": 40}})).unwrap();
+        let id = made["id"].as_i64().unwrap_or_default().to_string();
+        let v = read(b.as_mut(), &format!("vectorcraft://object/{id}")).unwrap();
+        assert_eq!(v["id"].to_string(), id);
+        assert!(v["bounds"].is_object(), "{v}");
+    }
+}

crates/mcp/src/server.rs

@@ -1,10 +1,12 @@
-//! JSON-RPC 2.0 framing and the MCP lifecycle / tools / resources methods.
+//! JSON-RPC 2.0 framing and the MCP lifecycle / tools / resources / prompts methods.
 
 use std::io::{BufRead, Write};
 
 use serde_json::{Value, json};
 
 use crate::backend::Backend;
+use crate::prompts;
+use crate::resources;
 use crate::tools::{call_tool, tool_definitions};
 
 /// The MCP revision we implement.
@@ -18,15 +20,14 @@ const INVALID_PARAMS: i64 = -32602;
 const INTERNAL_ERROR: i64 = -32603;
 const RESOURCE_NOT_FOUND: i64 = -32002;
 
-const INSTRUCTIONS: &str = "VectorCraft is a professional vector illustration app. Coordinates are points in \
-document space (y down, origin at the first artboard's top-left; a new document is 612×792). Draw with draw_shape / \
-draw_path, change colours with set_paint, look with screenshot and inspect_document. Every menu action is a command: \
-find it with list_commands and run it with run_command. New objects become the selection, and most commands act on the \
-selection (or on explicit `ids`).";
-
-/// Resource URIs.
-pub const DOC_URI: &str = "vectorcraft://document";
-pub const DOC_JSON_URI: &str = "vectorcraft://document/json";
+const INSTRUCTIONS: &str = "VectorCraft is a professional vector illustration app. Coordinates are \
+points in document space (y down, origin at the first artboard's top-left; a new document is 612×792). \
+Draw with draw_shape / draw_path, change colours with set_paint, look with screenshot and inspect_document. \
+Every menu action is a command: find it with list_commands and run it with run_command. New objects become \
+the selection, and most commands act on the selection (or on explicit `ids`). prompts/list has ready-made \
+workflows, completion/complete finishes a command id, a format, an effect or a swatch name, and \
+vectorcraft://object/{id}, vectorcraft://command/{id}, vectorcraft://effect/{id} and \
+vectorcraft://swatch/{name} read one thing at a time instead of the whole document.";
 
 /// An MCP server bound to one backend.
 pub struct Server {
@@ -56,16 +57,30 @@ impl Server {
         self.initialized
     }
 
+    /// The `notifications/message` records queued since the last call.
+    ///
+    /// Log records belong to no particular request, so these go out after the reply to whatever
+    /// line produced them rather than before it. [`serve`] drains this itself; a caller driving
+    /// [`handle_line`] by hand does the same.
+    pub fn take_notifications(&mut self) -> Vec<String> {
+        crate::logging::drain()
+            .into_iter()
+            .map(|record| json!({"jsonrpc": "2.0", "method": "notifications/message", "params": record}).to_string())
+            .collect()
+    }
+
     /// Serve newline-delimited JSON-RPC until `input` closes. Logs go to stderr only (stdout is
     /// the protocol stream).
     pub fn serve(&mut self, input: impl BufRead, mut output: impl Write) -> std::io::Result<()> {
         for line in input.lines() {
             let line = line?;
-            if let Some(reply) = self.handle_line(&line) {
-                output.write_all(reply.as_bytes())?;
+            let reply = self.handle_line(&line);
+            let notes = self.take_notifications();
+            for line in reply.iter().chain(notes.iter()) {
+                output.write_all(line.as_bytes())?;
                 output.write_all(b"\n")?;
-                output.flush()?;
             }
+            output.flush()?;
         }
         Ok(())
     }
@@ -135,7 +150,13 @@ impl Server {
                 let version = if SUPPORTED_VERSIONS.contains(&asked) { asked } else { PROTOCOL_VERSION };
                 Ok(json!({
                     "protocolVersion": version,
-                    "capabilities": {"tools": {}, "resources": {}},
+                    "capabilities": {
+                        "tools": {},
+                        "resources": {},
+                        "prompts": {"listChanged": false},
+                        "completions": {},
+                        "logging": {},
+                    },
                     "serverInfo": {"name": "vectorcraft", "title": "VectorCraft", "version": env!("CARGO_PKG_VERSION")},
                     "instructions": format!("{INSTRUCTIONS} Backend: {}.", self.backend.describe()),
                 }))
@@ -147,21 +168,38 @@ impl Server {
                 let args = params.get("arguments").cloned().unwrap_or(Value::Null);
                 Ok(call_tool(self.backend.as_mut(), name, &args).to_value())
             }
-            "resources/list" => Ok(json!({"resources": [
-                {"uri": DOC_URI, "name": "document", "title": "Active document (summary)", "description": "Layer tree, artboards, selection and history of the active document (document.inspect)", "mimeType": "application/json"},
-                {"uri": DOC_JSON_URI, "name": "document-json", "title": "Active document (full model)", "description": "The complete document model as JSON (document.json)", "mimeType": "application/json"},
-            ]})),
-            "resources/templates/list" => Ok(json!({"resourceTemplates": []})),
+            "resources/list" => Ok(resources::list()),
+            "resources/templates/list" => Ok(resources::templates()),
             "resources/read" => {
                 let uri = params.get("uri").and_then(Value::as_str).ok_or((INVALID_PARAMS, "missing `uri`".to_string()))?;
-                let v = match uri {
-                    DOC_URI => self.backend.call("document.inspect", json!({})),
-                    DOC_JSON_URI => self.backend.call("engine.execute", json!({"command": "document.json", "params": {}})),
-                    _ => return Err((RESOURCE_NOT_FOUND, format!("resource not found: {uri}"))),
-                }
-                .map_err(|e| (INTERNAL_ERROR, e))?;
+                let v = resources::read(self.backend.as_mut(), uri).map_err(|e| match e {
+                    resources::ReadError::NotFound(uri) => (RESOURCE_NOT_FOUND, format!("resource not found: {uri}")),
+                    resources::ReadError::Invalid(why) => (INVALID_PARAMS, why),
+                    resources::ReadError::Backend(why) => (INTERNAL_ERROR, why),
+                })?;
                 Ok(json!({"contents": [{"uri": uri, "mimeType": "application/json", "text": serde_json::to_string_pretty(&v).unwrap_or_default()}]}))
             }
+            "prompts/list" => Ok(prompts::list()),
+            "prompts/get" => {
+                let name = params.get("name").and_then(Value::as_str).ok_or((INVALID_PARAMS, "missing prompt `name`".to_string()))?;
+                let args = params.get("arguments").cloned().unwrap_or(Value::Null);
+                prompts::get(name, &args).map_err(|e| (INVALID_PARAMS, e))
+            }
+            "completion/complete" => Ok(prompts::complete(self.backend.as_mut(), params)),
+            "logging/setLevel" => {
+                // `level` is required. A null level is our own way of turning logging back off,
+                // which the spec has no method for and a long session needs.
+                let Some(asked) = params.get("level") else {
+                    return Err((INVALID_PARAMS, "missing `level`".into()));
+                };
+                let level = if asked.is_null() { None } else { asked.as_str() };
+                crate::logging::set_level(level).map_err(|_| match level {
+                    Some(given) => (INVALID_PARAMS, format!("unknown level `{given}`")),
+                    None => (INVALID_PARAMS, "`level` must be a severity name or null".to_string()),
+                })?;
+                log::debug!("client set logging to {}", level.unwrap_or("off"));
+                Ok(json!({}))
+            }
             other => Err((METHOD_NOT_FOUND, format!("method not found: {other}"))),
         }
     }

crates/mcp/src/tests.rs

@@ -284,6 +284,36 @@ fn headless_path_gesture_undo() {
     assert_eq!(&std::fs::read(tmp("x.png")).unwrap()[..4], b"\x89PNG");
 }
 
+/// inspect_document reads back the paint type's characters show, as add_text and set_paint give it.
+#[test]
+fn inspect_document_reports_the_paint_of_type() {
+    let mut s = server();
+    let r = call(&mut s, 2, "add_text", json!({"text": "HI", "x": 50, "y": 60, "size": 24, "color": "#ff0000"}));
+    assert_eq!(r["isError"], false, "{r}");
+    let id = serde_json::from_str::<Value>(&text_of(&r)).unwrap()["id"].clone();
+    let node = |s: &mut Server, n: u64| {
+        let v: Value = serde_json::from_str(&text_of(&call(s, n, "inspect_document", json!({})))).unwrap();
+        v["layers"][0]["children"].as_array().unwrap().iter().find(|c| c["id"] == id).cloned().unwrap()
+    };
+    let t = node(&mut s, 3);
+    assert_eq!((t["fill"].as_str(), t["stroke"].as_str()), (Some("#ff0000"), Some("None")), "{t}");
+    let r = call(&mut s, 4, "set_paint", json!({"fill": "#0000ff", "stroke": "#00ff00", "strokeWidth": 3, "ids": [id]}));
+    assert_eq!(r["isError"], false, "{r}");
+    let t = node(&mut s, 5);
+    assert_eq!((t["fill"].as_str(), t["stroke"].as_str(), t["strokeWidth"].as_f64()), (Some("#0000ff"), Some("#00ff00"), Some(3.0)), "{t}");
+}
+
+/// save_file says it saves in the document's own format or the one the path's extension picks.
+#[test]
+fn save_file_describes_the_formats_it_writes() {
+    let tools = tool_definitions();
+    let d = tools.iter().find(|t| t["name"] == "save_file").and_then(|t| t["description"].as_str()).unwrap();
+    for ext in [".vectorcraft", ".vctemplate", ".pdf", ".svg", ".svgz", ".ai"] {
+        assert!(d.contains(ext), "{ext}: {d}");
+    }
+    assert!(d.contains("its own format"), "{d}");
+}
+
 #[test]
 fn errors_are_tool_results_not_crashes() {
     let mut s = server();

crates/mcp/src/tests_protocol.rs

@@ -0,0 +1,219 @@
+//! The protocol surface beyond tools: prompts, completions, resource templates, subscriptions,
+//! logging, progress and cancellation, driven the way a client drives them.
+
+use serde_json::{Value, json};
+
+use crate::{Headless, PROMPTS, Server};
+
+fn server() -> Server {
+    Server::new(Box::new(Headless::with_document()))
+}
+
+/// One request, and whatever the server queued while answering it.
+fn rpc(s: &mut Server, id: u64, method: &str, params: Value) -> (Value, Vec<Value>) {
+    let line = json!({"jsonrpc": "2.0", "id": id, "method": method, "params": params}).to_string();
+    let reply = s.handle_line(&line).and_then(|r| serde_json::from_str::<Value>(&r).ok());
+    let notes: Vec<Value> = s.take_notifications().iter().filter_map(|l| serde_json::from_str(l).ok()).collect();
+    let reply = reply.unwrap_or(Value::Null);
+    assert_eq!(reply["jsonrpc"], "2.0", "{reply}");
+    assert_eq!(reply["id"], id, "{reply}");
+    (reply, notes)
+}
+
+fn result(s: &mut Server, id: u64, method: &str, params: Value) -> Value {
+    let (v, _) = rpc(s, id, method, params);
+    assert!(v.get("error").is_none(), "{method}: {v}");
+    v["result"].clone()
+}
+
+/// Run a tool and parse the JSON it answers with.
+fn tool(s: &mut Server, id: u64, name: &str, args: Value) -> Value {
+    let r = result(s, id, "tools/call", json!({"name": name, "arguments": args}));
+    assert_eq!(r["isError"], false, "{name}: {r}");
+    let text = r["content"][0]["text"].as_str().unwrap_or("null");
+    serde_json::from_str(text).unwrap_or(Value::Null)
+}
+
+/// Draw a rectangle and return its id.
+fn rectangle(s: &mut Server, id: u64) -> i64 {
+    let made = tool(s, id, "draw_shape", json!({"shape": "rectangle", "x": 10, "y": 10, "width": 60, "height": 40}));
+    made["id"].as_i64().unwrap_or_default()
+}
+
+fn err_code(s: &mut Server, id: u64, method: &str, params: Value) -> i64 {
+    let (v, _) = rpc(s, id, method, params);
+    v.get("error").and_then(|e| e["code"].as_i64()).unwrap_or_else(|| panic!("{method} should have failed: {v}"))
+}
+
+// ---------- capabilities ----------
+
+#[test]
+fn initialize_advertises_what_the_server_actually_answers() {
+    let mut s = server();
+    let caps = result(&mut s, 1, "initialize", json!({}))["capabilities"].clone();
+    assert!(caps["tools"].is_object(), "{caps}");
+    assert!(caps["resources"].is_object(), "{caps}");
+    // No `subscribe`: this server cannot observe a change while a call is running, so it does not
+    // claim to. Advertising a capability that silently misses edits is worse than not having it.
+    assert!(caps["resources"].get("subscribe").is_none(), "{caps}");
+    assert!(caps["prompts"].is_object(), "prompts are implemented");
+    assert!(caps["completions"].is_object(), "completion/complete is implemented");
+    assert!(caps["logging"].is_object(), "logging/setLevel is implemented");
+    // And the instructions point at them, since that is where a client looks first.
+    let instructions = result(&mut s, 2, "initialize", json!({}))["instructions"].as_str().unwrap_or_default().to_string();
+    assert!(instructions.contains("prompts/list"), "{instructions}");
+    assert!(instructions.contains("points in document space"), "{instructions}");
+}
+
+// ---------- prompts ----------
+
+#[test]
+fn prompts_are_listed_and_rendered_over_the_protocol() {
+    let mut s = server();
+    let listed = result(&mut s, 1, "prompts/list", json!({}))["prompts"].clone();
+    let entries = listed.as_array().expect("prompts");
+    assert_eq!(entries.len(), PROMPTS.len());
+    for e in entries {
+        assert!(e["name"].as_str().is_some_and(|n| !n.is_empty()), "{e}");
+        assert!(e["description"].as_str().is_some_and(|d| d.len() > 20), "{e}");
+        // Arguments are advertised with the flag prompts/get honours.
+        for a in e["arguments"].as_array().map_or(&[][..], Vec::as_slice) {
+            assert!(a["required"].is_boolean(), "{a}");
+        }
+    }
+
+    let got = result(&mut s, 2, "prompts/get", json!({"name": "poster", "arguments": {"brief": "a jazz festival"}}));
+    assert_eq!(got["messages"].as_array().map(Vec::len), Some(1));
+    assert_eq!(got["messages"][0]["role"], "user");
+    let text = got["messages"][0]["content"]["text"].as_str().unwrap_or_default();
+    assert!(text.contains("a jazz festival"), "{text}");
+}
+
+#[test]
+fn prompt_argument_errors_are_invalid_params() {
+    let mut s = server();
+    assert_eq!(err_code(&mut s, 1, "prompts/get", json!({"name": "poster"})), -32602);
+    assert_eq!(err_code(&mut s, 2, "prompts/get", json!({"name": "nope"})), -32602);
+    assert_eq!(err_code(&mut s, 3, "prompts/get", json!({})), -32602);
+}
+
+// ---------- completions ----------
+
+#[test]
+fn completions_come_from_the_live_catalogues() {
+    let mut s = server();
+    // A prompt argument fed by the export formats.
+    let v = result(
+        &mut s,
+        1,
+        "completion/complete",
+        json!({"ref": {"type": "ref/prompt", "name": "export-set"}, "argument": {"name": "formats", "value": "sv"}}),
+    );
+    let values: Vec<&str> = v["completion"]["values"].as_array().map_or(Vec::new(), |a| a.iter().filter_map(Value::as_str).collect());
+    assert!(values.contains(&"svg"), "{v}");
+    assert_eq!(v["completion"]["hasMore"], false);
+
+    // A resource template variable, after something exists to point at.
+    rectangle(&mut s, 2);
+    let v = result(
+        &mut s,
+        3,
+        "completion/complete",
+        json!({"ref": {"type": "ref/resource", "uri": "vectorcraft://object/{id}"}, "argument": {"name": "id", "value": ""}}),
+    );
+    let values = v["completion"]["values"].as_array().map_or(0, Vec::len);
+    assert!(values > 0, "{v}");
+    assert!(v["completion"]["total"].as_u64().unwrap_or(0) >= values as u64);
+}
+
+// ---------- resource templates ----------
+
+#[test]
+fn templates_are_listed_and_readable() {
+    let mut s = server();
+    let listed = result(&mut s, 1, "resources/templates/list", json!({}));
+    let templates = listed["resourceTemplates"].as_array().expect("templates");
+    assert!(templates.len() >= 4, "{listed}");
+
+    let id = rectangle(&mut s, 2);
+
+    let read = result(&mut s, 3, "resources/read", json!({"uri": format!("vectorcraft://object/{id}")}));
+    let body: Value = serde_json::from_str(read["contents"][0]["text"].as_str().unwrap_or("{}")).unwrap_or_default();
+    assert_eq!(body["id"].as_i64(), Some(id), "{body}");
+    assert!(body["bounds"].is_object(), "{body}");
+
+    // A command definition is one small read instead of the whole 400-command catalogue.
+    let read = result(&mut s, 4, "resources/read", json!({"uri": "vectorcraft://command/paint.setFill"}));
+    let body: Value = serde_json::from_str(read["contents"][0]["text"].as_str().unwrap_or("{}")).unwrap_or_default();
+    assert_eq!(body["id"], "paint.setFill", "{body}");
+    assert!(body["params"].as_str().is_some_and(|p| !p.is_empty()), "{body}");
+
+    // An effect's parameters and defaults.
+    let read = result(&mut s, 5, "resources/read", json!({"uri": "vectorcraft://effect/stylize.dropShadow"}));
+    let body: Value = serde_json::from_str(read["contents"][0]["text"].as_str().unwrap_or("{}")).unwrap_or_default();
+    assert_eq!(body["id"], "stylize.dropShadow", "{body}");
+
+    // Missing values and unknown resources are distinguishable.
+    assert_eq!(err_code(&mut s, 6, "resources/read", json!({"uri": "vectorcraft://object/"})), -32602);
+    assert_eq!(err_code(&mut s, 7, "resources/read", json!({"uri": "vectorcraft://command/nope"})), -32602);
+    assert_eq!(err_code(&mut s, 8, "resources/read", json!({"uri": "vectorcraft://nope"})), -32002);
+}
+
+// ---------- logging ----------
+
+#[test]
+fn logging_levels_are_validated_and_off_by_default() {
+    let _turn = crate::logging::test_turn();
+    let mut s = server();
+    assert_eq!(crate::logging::level(), None, "silent until asked for");
+    result(&mut s, 1, "logging/setLevel", json!({"level": "debug"}));
+    assert_eq!(crate::logging::level(), Some("debug"));
+    // A null level turns it back off; a missing one is a bad request.
+    result(&mut s, 2, "logging/setLevel", json!({"level": null}));
+    assert_eq!(crate::logging::level(), None);
+    assert_eq!(err_code(&mut s, 3, "logging/setLevel", json!({"level": "shouty"})), -32602);
+    assert_eq!(err_code(&mut s, 4, "logging/setLevel", json!({})), -32602);
+    // A rejected level leaves the accepted one alone.
+    result(&mut s, 5, "logging/setLevel", json!({"level": "warning"}));
+    assert_eq!(err_code(&mut s, 6, "logging/setLevel", json!({"level": "shouty"})), -32602);
+    assert_eq!(crate::logging::level(), Some("warning"));
+    result(&mut s, 7, "logging/setLevel", json!({"level": null}));
+    assert_eq!(crate::logging::level(), None);
+}
+
+/// Log records reach the client as `notifications/message`, and only after it asked.
+#[test]
+fn log_records_go_out_as_notifications_once_asked_for() {
+    let _turn = crate::logging::test_turn();
+    // The binary installs the logger, not the library, so a test does it for itself.
+    crate::logging::install();
+    let mut s = server();
+
+    let input = [
+        json!({"jsonrpc": "2.0", "id": 1, "method": "logging/setLevel", "params": {"level": "debug"}}).to_string(),
+        json!({"jsonrpc": "2.0", "id": 2, "method": "prompts/list"}).to_string(),
+        json!({"jsonrpc": "2.0", "id": 3, "method": "logging/setLevel", "params": {"level": null}}).to_string(),
+    ]
+    .join("\n");
+    let mut out = Vec::new();
+    s.serve(input.as_bytes(), &mut out).unwrap();
+    let lines: Vec<Value> = String::from_utf8(out).unwrap().lines().map(|l| serde_json::from_str(l).unwrap()).collect();
+
+    let notes: Vec<&Value> = lines.iter().filter(|l| l["method"] == "notifications/message").collect();
+    assert!(!notes.is_empty(), "the level change itself is logged: {lines:?}");
+    for n in &notes {
+        assert_eq!(n["jsonrpc"], "2.0", "{n}");
+        assert!(
+            ["debug", "info", "notice", "warning", "error", "critical", "alert", "emergency"]
+                .contains(&n["params"]["level"].as_str().unwrap_or_default()),
+            "{n}"
+        );
+        assert!(n["params"]["data"].is_string(), "{n}");
+    }
+    // Every reply still came before the notifications that followed it.
+    let answered = lines.iter().filter(|l| l.get("id").is_some()).count();
+    assert_eq!(answered, 3, "{lines:?}");
+    let last_reply = lines.iter().rposition(|l| l.get("id").is_some()).unwrap_or(0);
+    assert!(lines[last_reply + 1..].iter().all(|l| l.get("id").is_none()), "{lines:?}");
+    result(&mut s, 4, "logging/setLevel", json!({"level": null}));
+}

crates/mcp/src/tools.rs

@@ -2,7 +2,7 @@
 //! [`Backend`].
 
 use serde_json::{Map, Value, json};
-use vectorcraft_engine::cmd::fileio::{ARTBOARD_PARAMS, FORMATS, OPEN_EXTS};
+use vectorcraft_engine::cmd::fileio::{ARTBOARD_PARAMS, FORMATS, OPEN_EXTS, SAVE_FORMATS, format};
 
 use crate::backend::Backend;
 
@@ -57,6 +57,12 @@ fn obj(props: Value, required: &[&str]) -> Value {
     }
     o
 }
+
+/// The extension of each format Save writes, in [`SAVE_FORMATS`] order.
+fn save_extensions() -> Vec<&'static str> {
+    SAVE_FORMATS.iter().filter_map(|id| format(id)?.extensions.first().copied()).collect()
+}
+
 fn tool(name: &str, title: &str, desc: &str, schema: Value, read_only: bool) -> Value {
     json!({
         "name": name,
@@ -259,14 +265,17 @@ pub fn tool_definitions() -> Vec<Value> {
         tool(
             "save_file",
             "Save file",
-            "Save the active document in the native .vectorcraft format.",
-            obj(json!({"path": string("Destination (default: the document's current path)")}), &[]),
+            &format!(
+                "Save the active document with the engine's document.save: by default to its own file in its own format (native .vectorcraft unless it was opened from or saved as SVG, PDF or a restorable .ai). With `path`, the extension picks the format: .{}. Other formats are exports (see export). The reply's `format` says what was written and `warnings` what that format loses.",
+                save_extensions().join(", .")
+            ),
+            obj(json!({"path": string("Destination; its extension picks the format (default: the document's own file)")}), &[]),
             false,
         ),
         tool(
             "export",
             "Export",
-            "Export the active document with the engine's document.export (the same bytes in the app and headless): svg (artboard viewBox), pdf (one page per artboard: all, or `artboard` / `range`), png/jpg/webp/gif/png8/tiff/bmp/tga/psd (one rendered artboard; png8 is an indexed .png; psd keeps the layers), txt (the stories, back to front) or vectorcraft (a native copy; the document keeps its path). `selection: true` exports only the selected objects, cropped to their bounds. Template layers are left out; live effects are kept (geometry baked, SVG filters for shadows/glows/blur). Without `path` the bytes come back as dataBase64.",
+            "Export the active document with the engine's document.export (the same bytes in the app and headless), in any format of the `format` enum: vectors (svg/svgz with the artboard as viewBox, eps, dxf, emf, wmf), pdf (one page per artboard: all, or `artboard` / `range`), rasters (one rendered artboard: png, jpg, webp, gif, png8 as an indexed .png, tiff, bmp, tga, psd with its layers), txt (the stories, back to front), vectorcraft or template (a native copy or template; the document keeps its path). run_command document.formats lists each format's options. `selection: true` exports only the selected objects, cropped to their bounds. Template layers are left out; live effects are kept (geometry baked, SVG filters for shadows/glows/blur). Without `path` the bytes come back as dataBase64.",
             obj(
                 json!({
                     "format": {"type": "string", "enum": FORMATS.iter().filter(|f| f.write).map(|f| f.id).collect::<Vec<_>>(), "description": "Default: from the path's extension"},

crates/mcp/tests/protocol_props.rs

@@ -182,6 +182,237 @@ fn resources_are_json() {
     }
 }
 
+// ---------- prompts, completions, templates, subscriptions ----------
+
+/// Every prompt is well formed and renders whatever it is handed.
+#[test]
+fn prompts_are_valid_and_render_with_junk_arguments() {
+    let mut s = server();
+    let listed = rpc(&mut s, 1, "prompts/list", json!({}));
+    let prompts = listed["result"]["prompts"].as_array().unwrap();
+    assert!(!prompts.is_empty());
+    let mut failures = vec![];
+    for p in prompts {
+        let name = p["name"].as_str().unwrap();
+        assert!(p["description"].as_str().unwrap().len() > 20, "{name}");
+        let args: Vec<&str> = p["arguments"].as_array().map_or(&[][..], Vec::as_slice).iter().filter_map(|a| a["name"].as_str()).collect();
+        // Missing, empty, junk and hostile arguments all either render or fail cleanly.
+        let mut cases = vec![json!({}), Value::Null, json!([]), json!("x")];
+        for a in &args {
+            for v in junk_values() {
+                cases.push(json!({ *a: v }));
+                cases.push(json!({ *a: { "nested": v.clone() } }));
+                cases.push(json!({ *a: [v.clone()] }));
+            }
+        }
+        // Filled with every argument, the prompt must render.
+        let full: Value = json!(args.iter().map(|a| (*a, "value")).collect::<std::collections::BTreeMap<_, _>>());
+        cases.push(full);
+        for arguments in cases {
+            let r = catch_quiet(|| rpc(&mut s, 2, "prompts/get", json!({"name": name, "arguments": arguments.clone()})));
+            match r {
+                Err(p) => failures.push(format!("PANIC {name} {arguments}: {p}")),
+                Ok(v) => {
+                    assert!(v["result"].is_object() || v["error"]["code"] == -32602, "{name} {arguments}: {v}");
+                    // Whatever it returned is valid JSON text in a message.
+                    if let Some(messages) = v["result"]["messages"].as_array() {
+                        for m in messages {
+                            assert!(["user", "assistant"].contains(&m["role"].as_str().unwrap()), "{m}");
+                            assert!(m["content"]["text"].is_string(), "{m}");
+                        }
+                    }
+                }
+            }
+        }
+    }
+    assert!(failures.is_empty(), "{} failures:\n{}", failures.len(), failures.join("\n"));
+}
+
+/// `completion/complete` answers for every prompt argument and never panics on junk.
+#[test]
+fn completions_are_well_formed_and_survive_junk() {
+    let mut s = server();
+    let listed = rpc(&mut s, 1, "prompts/list", json!({}));
+    let mut cases = vec![];
+    for p in listed["result"]["prompts"].as_array().unwrap() {
+        let name = p["name"].as_str().unwrap();
+        for a in p["arguments"].as_array().map_or(&[][..], Vec::as_slice) {
+            let arg = a["name"].as_str().unwrap();
+            for value in ["", "a", "svg", "%20", "..", &"x".repeat(300)] {
+                cases.push(json!({"ref": {"type": "ref/prompt", "name": name}, "argument": {"name": arg, "value": value}}));
+            }
+        }
+        // An argument the prompt does not have, and a prompt that does not exist.
+        cases.push(json!({"ref": {"type": "ref/prompt", "name": name}, "argument": {"name": "nope", "value": ""}}));
+        cases.push(json!({"ref": {"type": "ref/prompt", "name": "nope"}, "argument": {"name": "x", "value": ""}}));
+    }
+    for t in templates(&mut s) {
+        for v in ["", "1", "%", "vectorcraft://x"] {
+            cases.push(json!({"ref": {"type": "ref/resource", "uri": t["uriTemplate"]}, "argument": {"name": "id", "value": v}}));
+        }
+    }
+    // And malformed references of every shape.
+    for junk in [json!({}), json!(null), json!([]), json!("x")] {
+        cases.push(junk);
+    }
+    for junk in junk_values().into_iter().take(12) {
+        cases.push(junk);
+    }
+
+    let mut failures = vec![];
+    for params in cases {
+        let r = catch_quiet(|| rpc(&mut s, 2, "completion/complete", params.clone()));
+        match r {
+            Err(p) => failures.push(format!("PANIC {params}: {p}")),
+            Ok(v) => {
+                assert!(v.get("error").is_none(), "{params}: {v}");
+                let completion = &v["result"]["completion"];
+                let values = completion["values"].as_array().unwrap_or_else(|| panic!("{params}: no values"));
+                assert!(values.len() <= 100, "{params}: {} values", values.len());
+                assert!(values.iter().all(Value::is_string), "{params}: {v}");
+                if let Some(total) = completion["total"].as_u64() {
+                    assert!(total >= values.len() as u64, "{params}: {v}");
+                }
+                assert_eq!(completion["hasMore"], total_exceeds(completion), "{params}: {v}");
+            }
+        }
+    }
+    assert!(failures.is_empty(), "{} failures:\n{}", failures.len(), failures.join("\n"));
+}
+
+/// `hasMore` is set exactly when the catalogue held more than we sent.
+fn total_exceeds(completion: &Value) -> Value {
+    let sent = completion["values"].as_array().map_or(0, Vec::len);
+    json!(completion["total"].as_u64().is_some_and(|t| t > sent as u64))
+}
+
+fn templates(s: &mut Server) -> Vec<Value> {
+    rpc(s, 9, "resources/templates/list", json!({}))["result"]["resourceTemplates"].as_array().unwrap().clone()
+}
+
+/// Every template lists with a variable, and reading it answers JSON or a clean error.
+#[test]
+fn resource_templates_are_addressable() {
+    let mut s = server();
+    let mut failures = vec![];
+    for t in templates(&mut s) {
+        let uri = t["uriTemplate"].as_str().unwrap();
+        assert!(uri.contains('{') && uri.ends_with('}'), "{t}");
+        assert!(t["description"].as_str().unwrap().len() > 20, "{t}");
+        assert!(t["mimeType"].is_string(), "{t}");
+        // A template with its variable left empty, filled with junk, and with a real value.
+        let prefix = uri.split('{').next().unwrap();
+        let mut uris = vec![prefix.to_string(), format!("{prefix}{{"), format!("{prefix}%20"), format!("{prefix}-1")];
+        let made = call(&mut s, "draw_shape", json!({"shape": "rectangle", "x": 1, "y": 1, "width": 20, "height": 20}));
+        if let Some(id) =
+            made["result"]["content"][0]["text"].as_str().and_then(|t| serde_json::from_str::<Value>(t).ok()).and_then(|v| v["id"].as_i64())
+        {
+            uris.push(format!("{prefix}{id}"));
+        }
+        for uri in uris {
+            let r = catch_quiet(|| rpc(&mut s, 10, "resources/read", json!({"uri": uri.clone()})));
+            match r {
+                Err(p) => failures.push(format!("PANIC {uri}: {p}")),
+                Ok(v) => {
+                    if let Some(text) = v["result"]["contents"][0]["text"].as_str() {
+                        serde_json::from_str::<Value>(text).unwrap_or_else(|e| panic!("{uri} is not JSON: {e}"));
+                    } else {
+                        let code = v["error"]["code"].as_i64().unwrap_or_default();
+                        assert!(code == -32602 || code == -32002, "{uri}: {v}");
+                    }
+                }
+            }
+        }
+    }
+    assert!(failures.is_empty(), "{}", failures.join("\n"));
+}
+
+/// Anything a client may send for the prompts, completion, logging and template methods leaves the
+/// server answering and the document valid.
+#[test]
+fn the_new_methods_survive_junk_and_keep_the_document_valid() {
+    let mut failures = vec![];
+    let mut s = server();
+    rpc(&mut s, 1, "tools/call", json!({"name": "draw_shape", "arguments": {"shape": "rectangle", "x": 0, "y": 0, "width": 30, "height": 20}}));
+    let before = doc_json(&document(&mut s));
+
+    let mut cases: Vec<(&str, Value)> = vec![];
+    for uri in ["vectorcraft://document", "vectorcraft://object/1", "vectorcraft://nope", "", "x://y", "%"] {
+        cases.push(("resources/read", json!({"uri": uri})));
+        cases.push(("resources/read", json!({})));
+        cases.push(("resources/read", json!({"uri": 5})));
+    }
+    for level in [json!("debug"), json!("emergency"), json!(null), json!("shouty"), json!(5), json!([]), json!({})] {
+        cases.push(("logging/setLevel", json!({"level": level})));
+    }
+    cases.push(("logging/setLevel", json!({})));
+    for name in [json!("poster"), json!("nope"), json!(""), json!(5), json!(null), json!([])] {
+        cases.push(("prompts/get", json!({"name": name})));
+        cases.push(("prompts/get", json!({"name": name, "arguments": []})));
+    }
+    for ref_ in [
+        json!({"type": "ref/prompt", "name": "poster"}),
+        json!({"type": "ref/resource", "uri": "vectorcraft://object/{id}"}),
+        json!({"type": "ref/other"}),
+        json!("x"),
+        json!([]),
+    ] {
+        cases.push(("completion/complete", json!({"ref": ref_, "argument": {"name": "brief", "value": ""}})));
+        cases.push(("completion/complete", json!({"ref": ref_})));
+    }
+
+    for (method, params) in cases {
+        let r = catch_quiet(|| rpc(&mut s, 11, method, params.clone()));
+        match r {
+            Err(p) => failures.push(format!("PANIC {method} {params}: {p}")),
+            Ok(v) => {
+                assert!(v.get("result").is_some() != v.get("error").is_some(), "{method} {params}: {v}");
+                // Whatever it answered, every notification it queued is a JSON-RPC message.
+                for line in s.take_notifications() {
+                    let n: Value = serde_json::from_str(&line).unwrap_or_else(|e| panic!("bad notification {line}: {e}"));
+                    assert_eq!(n["jsonrpc"], "2.0", "{n}");
+                    assert_eq!(n["method"], "notifications/message", "{n}");
+                    assert!(n["params"]["level"].is_string() && n["params"]["data"].is_string(), "{n}");
+                }
+                check_document(&document(&mut s)).unwrap_or_else(|e| failures.push(format!("{method} {params}: {e}")));
+            }
+        }
+    }
+    // None of these edit the document, so it must be exactly as it was.
+    assert_eq!(doc_json(&document(&mut s)), before, "a read-only method changed the document");
+    assert!(failures.is_empty(), "{} failures:\n{}", failures.len(), failures.join("\n"));
+}
+
+/// Every capability the server advertises is one it actually answers.
+#[test]
+fn advertised_capabilities_all_answer() {
+    let mut s = server();
+    let caps = rpc(&mut s, 1, "initialize", json!({}))["result"]["capabilities"].clone();
+    let checks: Vec<(&str, &str, Value)> = vec![
+        ("tools", "tools/list", json!({})),
+        ("prompts", "prompts/list", json!({})),
+        ("completions", "completion/complete", json!({"ref": {"type": "ref/prompt", "name": "poster"}, "argument": {"name": "brief", "value": ""}})),
+        ("logging", "logging/setLevel", json!({"level": null})),
+        ("resources", "resources/list", json!({})),
+        ("resources", "resources/templates/list", json!({})),
+        ("resources", "resources/read", json!({"uri": doc_uri_json(&mut s)})),
+    ];
+    for (capability, method, params) in checks {
+        assert!(caps[capability].is_object(), "{capability} is not advertised: {caps}");
+        assert!(rpc(&mut s, 2, method, params).get("error").is_none(), "{method} is advertised but does not answer");
+    }
+    // And nothing is advertised that the server does not answer.
+    assert!(caps["resources"].get("subscribe").is_none(), "subscribe is advertised but not implemented: {caps}");
+    assert_eq!(err_code(&mut s, 3, "resources/subscribe", json!({"uri": "vectorcraft://document"})), -32601);
+}
+
+/// A capability the server advertises must be one it answers, and one it does not advertise must
+/// not be there.
+fn err_code(s: &mut Server, id: u64, method: &str, params: Value) -> i64 {
+    let v = rpc(s, id, method, params);
+    v.get("error").and_then(|e| e["code"].as_i64()).unwrap_or_else(|| panic!("{method} should have failed: {v}"))
+}
+
 #[test]
 fn undo_redo_tools_restore_documents() {
     let mut s = server();

crates/pathops/README.md

@@ -1,6 +1,6 @@
 # vectorcraft-pathops
 
-Path operations for VectorCraft: booleans, the Pathfinder panel, Shape Builder regions, offset path, outline stroke, simplify and the other Object → Path commands. Everything takes and returns `vectorcraft_geom::PathData`.
+Path operations for VectorCraft: booleans, the Pathfinder panel, Shape Builder regions, Live Paint planar maps, offset path, outline stroke, simplify and the other Object → Path commands. Everything takes and returns `vectorcraft_geom::PathData`.
 
 ## Booleans (curve-preserving)
 
@@ -49,6 +49,15 @@ Each result takes its key as follows:
 | Crop | Keeps the visible parts of the lower objects inside the front-most object |
 | Outline | Returns open edge paths, split at every junction; coincident edges are de-duplicated, and each keeps the front-most key |
 
+## Live Paint
+
+```rust
+pub fn live_paint(shapes: &[Shape] /* back → front */) -> (Vec<Region>, Vec<Shape>); // (faces, edges)
+pub fn interior_point(path: &PathData) -> Option<Point>;
+```
+
+Unlike `regions`, which splits the filled areas of closed shapes, `live_paint` treats every path as an edge, open paths included. Three crossing lines enclose a triangle, a line across a rectangle splits it in two, and an area enclosed by paths becomes a face even when nothing fills it. Each face lists the inputs whose fill covers it; the list is empty for an area that is only enclosed by paths. Each edge is a piece of a path, split wherever another path meets it, and keeps the key of the front-most input it lies on.
+
 ## Offset / stroke
 
 ```rust

crates/pathops/src/boolean.rs

@@ -157,7 +157,7 @@ fn el_points(el: &kurbo::PathEl) -> impl Iterator<Item = Point> {
 /// handle within `eps` of its anchor's height is levelled with it (no y-extremum is left in a
 /// sub-`eps` sliver of a curve). Anchors move by less than `eps` and handles by less than `2·eps`,
 /// the order of the sweep's own tolerance.
-fn snap_horizontals(paths: &mut [&mut BezPath], eps: f64) {
+pub(crate) fn snap_horizontals(paths: &mut [&mut BezPath], eps: f64) {
     use kurbo::PathEl::*;
     let mut ys: Vec<f64> = paths.iter().flat_map(|p| p.elements().iter().filter_map(kurbo::PathEl::end_point)).map(|p| p.y).collect();
     ys.sort_by(f64::total_cmp);
@@ -339,7 +339,7 @@ pub(crate) fn all_contours_to_path(c: &Contours, tidy: &Tidy) -> PathData {
 /// Contours whose mean width (2·area / perimeter) is below `precision` are numerical debris
 /// (e.g. the lens left between two coincident curves) and are dropped, like Illustrator's
 /// Pathfinder precision setting does.
-fn is_sliver(bp: &BezPath, precision: f64) -> bool {
+pub(crate) fn is_sliver(bp: &BezPath, precision: f64) -> bool {
     let a = bp.area().abs();
     let per = bp.perimeter(1e-6);
     per <= 0.0 || 2.0 * a / per < precision

crates/pathops/src/lib.rs

@@ -11,6 +11,7 @@ mod edit;
 mod fit;
 mod offset;
 mod pathfinder;
+mod planar;
 
 pub use boolean::{BoolOp, DEFAULT_PRECISION, area, boolean, boolean_n, normalize, try_boolean, try_normalize, unite_all};
 pub use edit::{
@@ -18,6 +19,7 @@ pub use edit::{
 };
 pub use offset::{Cap, Join, offset_path, outline_stroke, stroke_region};
 pub use pathfinder::{PathfinderOp, Region, Shape, merge_regions, pathfinder, region_at, regions};
+pub use planar::{interior_point, live_paint};
 
 /// Errors from fallible operations.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, thiserror::Error)]

crates/pathops/src/planar.rs

@@ -0,0 +1,815 @@
+//! Live Paint planar maps: the faces and edges a set of paths divides the plane into.
+//!
+//! Unlike Pathfinder [`regions`](crate::regions), which splits the *filled areas* of closed shapes,
+//! every path here is an edge, open ones included: three crossing lines enclose a triangle, a line
+//! across a rectangle splits it in two, and an area enclosed by paths is a face whether or not
+//! anything fills it.
+//!
+//! The sweep (`linesweeper`) only takes closed paths, so an open path goes in traced there and
+//! back. Its two passes would cancel out as winding numbers, so the sweep counts boundary crossings
+//! instead ([`Crossings`]), which never cancel. Faces are then walked on the planar graph of the
+//! sweep's output segments; which inputs an edge came from and which fills cover a face are found
+//! geometrically (the sweep's winding numbers can't be trusted once open paths and coincident
+//! edges are in).
+//!
+//! The sweep runs in a sheared frame ([`SHEAR`]): it merges the two passes of a *horizontal* open
+//! path as if they cancelled out, and in the sheared frame no edge drawn at a common angle (0°,
+//! 45°, 90°…) is horizontal. The shear is by a power of two, so it maps typical coordinates
+//! exactly and keeps exact coincidences (a corner on another shape's edge) exact.
+
+use std::collections::HashMap;
+
+use kurbo::{Affine, BezPath, CubicBez, ParamCurve, PathSeg, Point, Shape as _};
+use linesweeper::topology::{Topology, WindingNumber};
+use vectorcraft_geom::{FillRule, PathData};
+
+use crate::boolean::{DEFAULT_PRECISION, Seg, Tidy, eps_for, is_sliver, segs_to_subpath, snap_horizontals, tidy_segments, to_seg};
+use crate::pathfinder::{Region, Shape};
+
+/// The sweep's frame: y + x / 32. Only edges sloping -1/32 in the document are horizontal in it.
+const SHEAR: Affine = Affine::new([1.0, 1.0 / 32.0, 0.0, 1.0, 0.0, 0.0]);
+const UNSHEAR: Affine = Affine::new([1.0, -1.0 / 32.0, 0.0, 1.0, 0.0, 0.0]);
+
+/// Boundary crossings per input, counted from the far west: slot `2i` counts input `i`'s
+/// segments running one way, slot `2i + 1` the other. An open path traced there and back adds one
+/// to each, so its edges never cancel out of the map.
+#[derive(Clone, Debug, Default)]
+struct Crossings(Vec<u32>);
+
+impl Crossings {
+    fn get(&self, slot: usize) -> u32 {
+        self.0.get(slot).copied().unwrap_or(0)
+    }
+}
+
+impl PartialEq for Crossings {
+    fn eq(&self, other: &Self) -> bool {
+        (0..self.0.len().max(other.0.len())).all(|i| self.get(i) == other.get(i))
+    }
+}
+impl Eq for Crossings {}
+
+impl std::ops::Add for Crossings {
+    type Output = Crossings;
+    fn add(mut self, rhs: Self) -> Crossings {
+        self += rhs;
+        self
+    }
+}
+
+impl std::ops::AddAssign for Crossings {
+    fn add_assign(&mut self, rhs: Self) {
+        if self.0.len() < rhs.0.len() {
+            self.0.resize(rhs.0.len(), 0);
+        }
+        for (a, b) in self.0.iter_mut().zip(rhs.0) {
+            *a = a.saturating_add(b);
+        }
+    }
+}
+
+impl WindingNumber for Crossings {
+    type Tag = usize;
+    fn single(tag: usize, positive: bool) -> Self {
+        let slot = 2 * tag + usize::from(!positive);
+        let mut v = vec![0; slot + 1];
+        if let Some(c) = v.get_mut(slot) {
+            *c = 1;
+        }
+        Crossings(v)
+    }
+    fn of_tag(&self, tag: usize) -> Self {
+        let mut v = vec![0; 2 * tag + 2];
+        for slot in [2 * tag, 2 * tag + 1] {
+            if let Some(c) = v.get_mut(slot) {
+                *c = self.get(slot);
+            }
+        }
+        Crossings(v)
+    }
+}
+
+/// A point in the middle of a run of segments.
+fn mid(segs: &[Seg]) -> Option<Point> {
+    segs.get(segs.len() / 2).map(|s| s.c.eval(0.5))
+}
+
+/// The inputs' segments (in the sweep's frame), to tell which inputs an edge lies on.
+struct Outlines {
+    segs: Vec<(kurbo::Rect, PathSeg, usize)>,
+    tol: f64,
+}
+
+impl Outlines {
+    fn new(inputs: &[(BezPath, usize)], eps: f64) -> Self {
+        let segs = inputs.iter().flat_map(|(bp, i)| bp.segments().map(move |s| (s.bounding_box(), s, *i))).collect();
+        // The sweep moves points by a few `eps` at most.
+        Self { segs, tol: 16.0 * eps }
+    }
+
+    /// The front-most input whose outline passes through `p`.
+    fn source_at(&self, p: Point) -> Option<usize> {
+        use kurbo::ParamCurveNearest;
+        let tol = self.tol;
+        self.segs.iter().filter(|(r, s, _)| r.inflate(tol, tol).contains(p) && s.nearest(p, 1e-9).distance_sq <= tol * tol).map(|(_, _, i)| *i).max()
+    }
+}
+
+/// The area an input's fill covers: its closed subpaths (open ones bound no face).
+struct Fill {
+    path: BezPath,
+    bounds: kurbo::Rect,
+    rule: FillRule,
+}
+
+impl Fill {
+    fn new(s: &Shape) -> Self {
+        let mut path = BezPath::new();
+        for sp in s.path.subpaths.iter().filter(|sp| sp.closed && sp.anchors.len() >= 2) {
+            sp.to_bezpath_into(&mut path);
+        }
+        Self { bounds: path.bounding_box(), path, rule: s.rule }
+    }
+
+    fn contains(&self, p: Point) -> bool {
+        !self.path.elements().is_empty() && self.bounds.contains(p) && crate::boolean::inside(self.rule, self.path.winding(p))
+    }
+}
+
+/// One output segment of the sweep: an edge of the planar graph between two vertices.
+struct Edge {
+    segs: Vec<Seg>,
+    ends: [usize; 2],
+    /// The input it came from (the front-most, where inputs share it).
+    source: usize,
+}
+
+/// Half-edge `2e` runs along edge `e`, `2e + 1` back along it.
+fn twin(h: usize) -> usize {
+    h ^ 1
+}
+
+/// The segments of half-edge `h`, in its direction.
+fn half_segs(edges: &[Edge], h: usize) -> Vec<Seg> {
+    let Some(e) = edges.get(h / 2) else { return Vec::new() };
+    if h.is_multiple_of(2) {
+        e.segs.clone()
+    } else {
+        e.segs.iter().rev().map(|s| Seg { c: CubicBez::new(s.c.p3, s.c.p2, s.c.p1, s.c.p0), line: s.line }).collect()
+    }
+}
+
+/// The vertex half-edge `h` leaves from.
+fn origin(edges: &[Edge], h: usize) -> Option<usize> {
+    edges.get(h / 2).map(|e| e.ends[h % 2])
+}
+
+/// Where half-edge `h` (leaving `v`) first gets `r` away from it, as an angle around `v`.
+///
+/// Edges that only meet at `v` cross a circle around it in the order they leave `v` in, however
+/// they start out (tangent curves, or the sweep's short straight stubs at a vertex).
+fn leaving_angle(edges: &[Edge], h: usize, v: Point, r: f64) -> f64 {
+    let segs = half_segs(edges, h);
+    let mut bp = BezPath::new();
+    for (k, s) in segs.iter().enumerate() {
+        if k == 0 {
+            bp.move_to(s.c.p0);
+        }
+        bp.curve_to(s.c.p1, s.c.p2, s.c.p3);
+    }
+    let mut prev = segs.first().map_or(v, |s| s.c.p0);
+    let mut hit: Option<Point> = None;
+    kurbo::flatten(bp.iter(), (r * 1e-4).max(1e-12), |el| {
+        if let (None, kurbo::PathEl::LineTo(p)) = (hit, el) {
+            if p.distance(v) >= r {
+                // The point on prev → p at distance r (prev is closer).
+                let (d, f) = (p - prev, prev - v);
+                let (a, b, c) = (d.hypot2(), 2.0 * f.dot(d), f.hypot2() - r * r);
+                let t = if a > 0.0 { ((-b + (b * b - 4.0 * a * c).max(0.0).sqrt()) / (2.0 * a)).clamp(0.0, 1.0) } else { 1.0 };
+                hit = Some(prev + d * t);
+            }
+            prev = p;
+        }
+    });
+    // An edge too short to reach r (it can't, r is at most half of every chord) leaves along its
+    // tangent.
+    let far =
+        hit.unwrap_or_else(|| segs.first().map_or(v, |s| [s.c.p1, s.c.p2, s.c.p3].into_iter().find(|p| p.distance(s.c.p0) > 0.0).unwrap_or(s.c.p3)));
+    (far - v).atan2()
+}
+
+/// Path of a closed run of half-edges, tidied (split pieces of one input curve joined again).
+fn cycle_bezpath(edges: &[Edge], cycle: &[usize]) -> BezPath {
+    let mut bp = BezPath::new();
+    for (k, s) in cycle.iter().flat_map(|&h| half_segs(edges, h)).enumerate() {
+        if k == 0 {
+            bp.move_to(s.c.p0);
+        }
+        if s.line {
+            bp.line_to(s.c.p3);
+        } else {
+            bp.curve_to(s.c.p1, s.c.p2, s.c.p3);
+        }
+    }
+    bp.close_path();
+    bp
+}
+
+/// `cycle` without the spurs it runs out and back along (edges with the same face on both sides,
+/// such as a line's loose end).
+fn without_spurs(cycle: &[usize]) -> Vec<usize> {
+    let mut out: Vec<usize> = Vec::with_capacity(cycle.len());
+    for &h in cycle {
+        if out.last() == Some(&twin(h)) {
+            out.pop();
+        } else {
+            out.push(h);
+        }
+    }
+    // A spur where the walk started wraps around the ends.
+    while out.len() >= 2 && out.first().map(|&h| twin(h)) == out.last().copied() {
+        out.pop();
+        out.remove(0);
+    }
+    out
+}
+
+/// Append `open` traced there and back (a closed, zero-area path along it) to `out`.
+fn there_and_back(open: &BezPath, out: &mut BezPath) {
+    let segs: Vec<PathSeg> = open.segments().collect();
+    let Some(first) = segs.first() else { return };
+    out.move_to(first.start());
+    for s in &segs {
+        out.push(s.as_path_el());
+    }
+    for s in segs.iter().rev() {
+        out.push(s.reverse().as_path_el());
+    }
+    out.close_path();
+}
+
+/// `path` back from the sweep's frame, its anchors within `tol` of an input anchor (`sorted` by x)
+/// put exactly on it, handles moving with them.
+fn unshear(mut path: PathData, sorted: &[Point], tol: f64) -> PathData {
+    path.transform(UNSHEAR);
+    for a in path.subpaths.iter_mut().flat_map(|sp| sp.anchors.iter_mut()) {
+        let lo = sorted.partition_point(|q| q.x < a.p.x - tol);
+        if let Some(q) = sorted.get(lo..).unwrap_or_default().iter().take_while(|q| q.x <= a.p.x + tol).find(|q| (q.y - a.p.y).abs() <= tol) {
+            let d = *q - a.p;
+            a.p = *q;
+            a.h_in += d;
+            a.h_out += d;
+        }
+    }
+    path
+}
+
+fn find(parent: &mut [usize], mut v: usize) -> usize {
+    while let Some(&p) = parent.get(v) {
+        if p == v {
+            break;
+        }
+        let gp = parent.get(p).copied().unwrap_or(p);
+        if let Some(slot) = parent.get_mut(v) {
+            *slot = gp;
+        }
+        v = p;
+    }
+    v
+}
+
+/// The Live Paint planar map of `shapes` (back → front).
+///
+/// Faces are the bounded areas the paths enclose, holes included, each with the inputs whose fill
+/// covers it (ascending; empty for an area only enclosed by paths). Edges are the paths split
+/// wherever they meet another path, keyed by the input they came from (the front-most where
+/// inputs share one). Empty when the paths can't be swept (non-finite or too degenerate).
+pub fn live_paint(shapes: &[Shape]) -> (Vec<Region>, Vec<Shape>) {
+    build(shapes).unwrap_or_default()
+}
+
+fn build(shapes: &[Shape]) -> Option<(Vec<Region>, Vec<Shape>)> {
+    let mut inputs: Vec<(BezPath, usize)> = Vec::new();
+    for (i, s) in shapes.iter().enumerate() {
+        let mut bp = BezPath::new();
+        for sp in s.path.subpaths.iter().filter(|sp| sp.anchors.len() >= 2) {
+            if sp.closed {
+                sp.to_bezpath_into(&mut bp);
+            } else {
+                let mut open = BezPath::new();
+                sp.to_bezpath_into(&mut open);
+                there_and_back(&open, &mut bp);
+            }
+        }
+        if !bp.elements().is_empty() {
+            bp.apply_affine(SHEAR);
+            inputs.push((bp, i));
+        }
+    }
+    if inputs.is_empty() {
+        return None;
+    }
+    let eps = eps_for(inputs.iter().map(|p| &p.0)).ok()?;
+    snap_horizontals(&mut inputs.iter_mut().map(|p| &mut p.0).collect::<Vec<_>>(), eps);
+    // The sweep can panic on rare near-degenerate input; that must never take the app down.
+    let sweep =
+        std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| Topology::<Crossings>::from_paths(inputs.iter().map(|(p, i)| (p, *i)), eps)));
+    let top = sweep.ok()?.ok()?;
+    let tidy = Tidy::keeping(DEFAULT_PRECISION, inputs.iter().map(|p| &p.0));
+
+    // The planar graph: vertices are the sweep's points, edges its segments. Points closer than
+    // the sweep's tolerance are one vertex (it can put a corner that lies on another path's edge
+    // a rounding error away from where it cuts that edge).
+    let positions = top.compute_positions();
+    let cell = 4.0 * eps;
+    let mut grid: HashMap<(i64, i64), Vec<usize>> = HashMap::new();
+    let mut points: Vec<Point> = Vec::new();
+    let mut vertex_id = |p: Point| {
+        let (cx, cy) = ((p.x / cell).floor() as i64, (p.y / cell).floor() as i64);
+        let near = (cx - 1..=cx + 1)
+            .flat_map(|x| (cy - 1..=cy + 1).map(move |y| (x, y)))
+            .filter_map(|k| grid.get(&k))
+            .flatten()
+            .copied()
+            .find(|&v| points.get(v).is_some_and(|q| q.distance(p) <= eps));
+        near.unwrap_or_else(|| {
+            points.push(p);
+            grid.entry((cx, cy)).or_default().push(points.len() - 1);
+            points.len() - 1
+        })
+    };
+    let mut edges: Vec<Edge> = Vec::new();
+    let mut between: HashMap<(usize, usize), Vec<usize>> = HashMap::new();
+    let outlines = Outlines::new(&inputs, eps);
+    for idx in top.segment_indices() {
+        let half = idx.first_half();
+        let segs: Vec<Seg> = positions[idx].path.segments().map(to_seg).collect();
+        let ends = [vertex_id(top.point(half).to_kurbo()), vertex_id(top.point(idx.second_half()).to_kurbo())];
+        if segs.is_empty() || ends[0] == ends[1] {
+            continue;
+        }
+        let Some(source) = mid(&segs).and_then(|m| outlines.source_at(m)) else { continue };
+        // Coincident pieces the sweep left apart are one edge (the front-most input's).
+        let key = (ends[0].min(ends[1]), ends[0].max(ends[1]));
+        let here = mid(&segs);
+        let twin_of = between.get(&key).and_then(|v| {
+            v.iter().copied().find(|&e| {
+                let other = edges.get(e).and_then(|e| mid(&e.segs));
+                matches!((here, other), (Some(a), Some(b)) if a.distance(b) < DEFAULT_PRECISION)
+            })
+        });
+        if let Some(e) = twin_of {
+            if let Some(e) = edges.get_mut(e)
+                && source > e.source
+            {
+                e.source = source;
+            }
+            continue;
+        }
+        between.entry(key).or_default().push(edges.len());
+        edges.push(Edge { segs, ends, source });
+    }
+    let nv = points.len();
+
+    // Half-edges leaving each vertex, sorted by direction; walking a face, the next half-edge is
+    // the one just clockwise of the way back, so bounded faces come out with positive area and
+    // the outer boundary of each connected piece with negative area.
+    let mut around: Vec<Vec<usize>> = vec![Vec::new(); nv];
+    for h in 0..2 * edges.len() {
+        if let Some(list) = origin(&edges, h).and_then(|v| around.get_mut(v)) {
+            list.push(h);
+        }
+    }
+    let mut slot_of = vec![0usize; 2 * edges.len()];
+    for (v, list) in around.iter_mut().enumerate() {
+        let Some(&at) = points.get(v) else { continue };
+        // Half the shortest chord of the edges here: every one of them gets that far from it.
+        let r = 0.5 * list.iter().filter_map(|&h| half_segs(&edges, h).last().map(|s| s.c.p3.distance(at))).fold(f64::INFINITY, f64::min);
+        let mut keyed: Vec<(f64, usize)> = list.iter().map(|&h| (leaving_angle(&edges, h, at, r), h)).collect();
+        keyed.sort_by(|a, b| a.0.total_cmp(&b.0));
+        *list = keyed.into_iter().map(|(_, h)| h).collect();
+        for (k, &h) in list.iter().enumerate() {
+            if let Some(s) = slot_of.get_mut(h) {
+                *s = k;
+            }
+        }
+    }
+    let next = |h: usize| -> Option<usize> {
+        let back = twin(h);
+        let list = around.get(origin(&edges, back)?)?;
+        let k = *slot_of.get(back)?;
+        list.get((k + list.len() - 1) % list.len()).copied()
+    };
+
+    // Connected pieces of the graph.
+    let mut parent: Vec<usize> = (0..nv).collect();
+    for e in &edges {
+        let (a, b) = (find(&mut parent, e.ends[0]), find(&mut parent, e.ends[1]));
+        if let Some(p) = parent.get_mut(a) {
+            *p = b;
+        }
+    }
+    let piece: Vec<usize> = (0..nv).map(|v| find(&mut parent, v)).collect();
+    let piece_of = |cycle: &[usize]| cycle.first().and_then(|&h| origin(&edges, h)).and_then(|v| piece.get(v)).copied();
+
+    // Walk every cycle: positive ones are faces, negative ones outer boundaries (holes in the
+    // face around them, if any).
+    let mut seen = vec![false; 2 * edges.len()];
+    let mut faces: Vec<(Vec<usize>, BezPath, f64)> = Vec::new();
+    let mut holes: Vec<(Vec<usize>, BezPath)> = Vec::new();
+    for start in 0..2 * edges.len() {
+        if seen.get(start).copied().unwrap_or(true) {
+            continue;
+        }
+        let mut cycle = vec![];
+        let mut h = start;
+        while let Some(s) = seen.get_mut(h).filter(|s| !**s) {
+            *s = true;
+            cycle.push(h);
+            match next(h) {
+                Some(n) => h = n,
+                None => break,
+            }
+        }
+        let cycle = without_spurs(&cycle);
+        if cycle.is_empty() {
+            continue;
+        }
+        let bp = cycle_bezpath(&edges, &cycle);
+        let area = bp.area();
+        if area > 0.0 && !is_sliver(&bp, tidy.precision) {
+            faces.push((cycle, bp, area));
+        } else if area < -(tidy.precision * tidy.precision) {
+            holes.push((cycle, bp));
+        }
+    }
+
+    // Each hole goes in the smallest face of another piece around it.
+    let mut face_holes: Vec<Vec<usize>> = vec![Vec::new(); faces.len()];
+    for (k, (cycle, _)) in holes.iter().enumerate() {
+        let Some(p) = cycle.first().and_then(|&h| origin(&edges, h)).and_then(|v| points.get(v)).copied() else { continue };
+        let own = piece_of(cycle);
+        let around_it = faces
+            .iter()
+            .enumerate()
+            .filter(|(_, (fc, bp, _))| piece_of(fc) != own && bp.bounding_box().contains(p) && bp.winding(p) != 0)
+            .min_by(|a, b| a.1.2.total_cmp(&b.1.2))
+            .map(|(i, _)| i);
+        if let Some(list) = around_it.and_then(|i| face_holes.get_mut(i)) {
+            list.push(k);
+        }
+    }
+
+    let fills: Vec<Fill> = shapes.iter().map(Fill::new).collect();
+    // The inputs' anchors, which results land on again up to the sweep's tolerance.
+    let snap = 2.0 * eps;
+    let mut anchors: Vec<Point> = shapes.iter().flat_map(|s| s.path.subpaths.iter().flat_map(|sp| sp.anchors.iter().map(|a| a.p))).collect();
+    anchors.sort_by(|a, b| a.x.total_cmp(&b.x).then(a.y.total_cmp(&b.y)));
+    let subpath = |cycle: &[usize]| {
+        let segs: Vec<Seg> = cycle.iter().flat_map(|&h| half_segs(&edges, h)).collect();
+        segs_to_subpath(&tidy_segments(segs, true, &tidy), true)
+    };
+    let regions = faces
+        .iter()
+        .zip(&face_holes)
+        .filter_map(|((cycle, _, _), hs)| {
+            let mut subpaths = vec![subpath(cycle)?];
+            subpaths.extend(hs.iter().filter_map(|&k| holes.get(k)).filter_map(|(c, _)| subpath(c)));
+            let path = unshear(PathData::new(subpaths), &anchors, snap);
+            let sources =
+                interior_point(&path).map(|p| fills.iter().enumerate().filter(|(_, f)| f.contains(p)).map(|(i, _)| i).collect()).unwrap_or_default();
+            Some(Region { path, sources })
+        })
+        .collect();
+
+    // Edges: chains of segments through vertices where nothing else meets.
+    let degree: Vec<usize> = around.iter().map(Vec::len).collect();
+    let passes = |v: usize| -> Option<(usize, usize)> {
+        let list = around.get(v)?;
+        let (&a, &b) = (list.first()?, list.get(1)?);
+        (degree.get(v) == Some(&2) && edges.get(a / 2)?.source == edges.get(b / 2)?.source).then_some((a, b))
+    };
+    let mut used = vec![false; edges.len()];
+    let mut chains: Vec<(Vec<Seg>, bool, usize)> = Vec::new();
+    // A chain from half-edge `h0` up to the next vertex where it doesn't pass straight through;
+    // closed when it comes back round to where it started.
+    let walk = |h0: usize, used: &mut Vec<bool>| -> Option<(Vec<Seg>, bool, usize)> {
+        let source = edges.get(h0 / 2)?.source;
+        let mut segs = Vec::new();
+        let mut h = h0;
+        loop {
+            let u = used.get_mut(h / 2)?;
+            if *u {
+                return Some((segs, true, source));
+            }
+            *u = true;
+            segs.extend(half_segs(&edges, h));
+            let v = origin(&edges, twin(h))?;
+            let Some((a, b)) = passes(v) else { return Some((segs, origin(&edges, h0) == Some(v), source)) };
+            h = if a == twin(h) { b } else { a };
+        }
+    };
+    for v in 0..nv {
+        if passes(v).is_some() {
+            continue;
+        }
+        for &h in around.get(v).map(Vec::as_slice).unwrap_or_default() {
+            if !used.get(h / 2).copied().unwrap_or(true)
+                && let Some(c) = walk(h, &mut used)
+            {
+                chains.push(c);
+            }
+        }
+    }
+    // What's left are closed loops with no junction on them.
+    for e in 0..edges.len() {
+        if !used.get(e).copied().unwrap_or(true)
+            && let Some(c) = walk(2 * e, &mut used)
+        {
+            chains.push(c);
+        }
+    }
+    let edge_shapes = chains
+        .into_iter()
+        .filter_map(|(segs, closed, source)| {
+            let sp = segs_to_subpath(&tidy_segments(segs, closed, &tidy), closed)?;
+            Some(Shape::new(unshear(PathData::new(vec![sp]), &anchors, snap), FillRule::NonZero, shapes.get(source)?.key))
+        })
+        .collect();
+    Some((regions, edge_shapes))
+}
+
+/// A point strictly inside a filled path, well away from its edges where it can be (for re-finding
+/// a Live Paint face after a rebuild).
+pub fn interior_point(path: &PathData) -> Option<Point> {
+    let bb = path.bounds()?;
+    let bp = path.to_bezpath();
+    let mut edges: Vec<(Point, Point)> = vec![];
+    let (mut first, mut last) = (Point::ZERO, Point::ZERO);
+    kurbo::flatten(bp.iter(), (bb.width().max(bb.height()) * 1e-3).max(1e-4), |el| match el {
+        kurbo::PathEl::MoveTo(p) => {
+            if last != first {
+                edges.push((last, first));
+            }
+            first = p;
+            last = p;
+        }
+        kurbo::PathEl::LineTo(p) => {
+            edges.push((last, p));
+            last = p;
+        }
+        kurbo::PathEl::ClosePath => {
+            if last != first {
+                edges.push((last, first));
+            }
+            last = first;
+        }
+        _ => {}
+    });
+    if last != first {
+        edges.push((last, first));
+    }
+    let mut best: Option<(f64, Point)> = None;
+    for f in [0.5, 0.25, 0.75, 0.125, 0.375, 0.625, 0.875, 0.0625, 0.9375] {
+        // A little off the round fractions, which on art drawn to a grid fall on the height of
+        // some corner, where testing the point against other paths is unreliable.
+        let y = bb.y0 + bb.height() * (f + 0.0061803);
+        let mut xs: Vec<f64> =
+            edges.iter().filter(|(a, c)| (a.y <= y) != (c.y <= y)).map(|(a, c)| a.x + (y - a.y) / (c.y - a.y) * (c.x - a.x)).collect();
+        xs.sort_by(f64::total_cmp);
+        for w in xs.windows(2) {
+            let m = Point::new((w[0] + w[1]) / 2.0, y);
+            let width = w[1] - w[0];
+            if width > best.map_or(0.0, |b| b.0) && bp.winding(m) != 0 {
+                best = Some((width, m));
+            }
+        }
+    }
+    best.map(|b| b.1)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use proptest::prelude::*;
+    use vectorcraft_geom::{Rect, SubPath, shapes};
+
+    fn line(a: (f64, f64), b: (f64, f64), key: u64) -> Shape {
+        Shape::new(PathData::single(SubPath::polyline(&[Point::new(a.0, a.1), Point::new(b.0, b.1)], false)), FillRule::NonZero, key)
+    }
+
+    fn rect(x0: f64, y0: f64, x1: f64, y1: f64, key: u64) -> Shape {
+        Shape::new(shapes::rectangle(Rect::new(x0, y0, x1, y1)), FillRule::NonZero, key)
+    }
+
+    fn area(r: &Region) -> f64 {
+        r.path.to_bezpath().area()
+    }
+
+    fn at(faces: &[Region], x: f64, y: f64) -> Vec<&Region> {
+        faces.iter().filter(|f| f.contains(Point::new(x, y))).collect()
+    }
+
+    #[test]
+    fn crossing_lines_enclose_a_face() {
+        // Three lines crossing pairwise, their ends sticking out: one triangle.
+        let s = [line((0.0, 0.0), (100.0, 100.0), 0), line((100.0, 0.0), (0.0, 100.0), 1), line((-10.0, 80.0), (110.0, 80.0), 2)];
+        let (faces, edges) = live_paint(&s);
+        assert_eq!(faces.len(), 1, "{faces:?}");
+        let f = &faces[0];
+        assert!((area(f) - 900.0).abs() < 1e-6, "triangle (20,80) (50,50) (80,80): {}", area(f));
+        assert!(f.sources.is_empty(), "nothing fills it yet");
+        assert_eq!(f.path.subpaths.len(), 1);
+        assert_eq!(f.path.subpaths[0].anchors.len(), 3, "the loose ends are not part of it");
+        // Each line is cut where the others cross it: 3 + 3 + 3 pieces.
+        assert_eq!(edges.len(), 9);
+        assert_eq!(edges.iter().filter(|e| e.key == 2).count(), 3);
+    }
+
+    #[test]
+    fn a_grid_of_lines_makes_its_cells() {
+        let mut s = vec![];
+        for k in 0..4 {
+            let v = f64::from(k) * 10.0;
+            s.push(line((v, -5.0), (v, 35.0), 0));
+            s.push(line((-5.0, v), (35.0, v), 1));
+        }
+        let (faces, _) = live_paint(&s);
+        assert_eq!(faces.len(), 9);
+        assert!(faces.iter().all(|f| (area(f) - 100.0).abs() < 1e-6));
+        assert_eq!(at(&faces, 15.0, 15.0).len(), 1);
+    }
+
+    #[test]
+    fn a_line_across_a_shape_splits_it() {
+        let s = [rect(0.0, 0.0, 100.0, 50.0, 7), line((40.0, -20.0), (60.0, 70.0), 8)];
+        let (faces, edges) = live_paint(&s);
+        assert_eq!(faces.len(), 2);
+        assert!(faces.iter().all(|f| f.sources == [0]), "both halves keep the rectangle's fill");
+        assert!((faces.iter().map(area).sum::<f64>() - 5000.0).abs() < 1e-6);
+        assert_eq!(at(&faces, 10.0, 25.0).len(), 1);
+        assert_eq!(at(&faces, 90.0, 25.0).len(), 1);
+        // The rectangle's outline in two pieces, the line in three.
+        assert_eq!(edges.iter().filter(|e| e.key == 7).count(), 2);
+        assert_eq!(edges.iter().filter(|e| e.key == 8).count(), 3);
+    }
+
+    #[test]
+    fn overlapping_shapes_keep_their_coverage() {
+        let s = [rect(0.0, 0.0, 100.0, 100.0, 0), rect(50.0, 0.0, 150.0, 100.0, 1)];
+        let (faces, _) = live_paint(&s);
+        assert_eq!(faces.len(), 3);
+        assert_eq!(at(&faces, 25.0, 50.0)[0].sources, [0]);
+        assert_eq!(at(&faces, 75.0, 50.0)[0].sources, [0, 1]);
+        assert_eq!(at(&faces, 125.0, 50.0)[0].sources, [1]);
+        // Same faces as the Pathfinder regions.
+        let regions = crate::regions(&s);
+        assert_eq!(regions.len(), 3);
+        for f in &faces {
+            assert!(regions.iter().any(|r| r.sources == f.sources && (area(r).abs() - area(f)).abs() < 1e-6));
+        }
+    }
+
+    #[test]
+    fn a_closed_loop_of_lines_inside_a_shape_is_a_hole_and_a_face() {
+        let mut s = vec![rect(0.0, 0.0, 100.0, 100.0, 0)];
+        let sq = [(40.0, 40.0), (60.0, 40.0), (60.0, 60.0), (40.0, 60.0), (40.0, 40.0)];
+        for w in sq.windows(2) {
+            s.push(line(w[0], w[1], 1));
+        }
+        // A loose line inside: no face of its own, no hole.
+        s.push(line((10.0, 10.0), (20.0, 20.0), 2));
+        let (faces, _) = live_paint(&s);
+        assert_eq!(faces.len(), 2, "{faces:?}");
+        let outer = at(&faces, 5.0, 5.0);
+        assert_eq!(outer.len(), 1);
+        assert_eq!(outer[0].path.subpaths.len(), 2, "the inner square is a hole in it");
+        assert!((area(outer[0]) - 9600.0).abs() < 1e-6);
+        let inner = at(&faces, 50.0, 50.0);
+        assert_eq!(inner.len(), 1, "the hole doesn't count as the outer face");
+        assert_eq!(inner[0].sources, [0], "the rectangle fills it");
+        assert!((area(inner[0]) - 400.0).abs() < 1e-6);
+    }
+
+    #[test]
+    fn an_area_enclosed_by_shapes_is_an_unfilled_face() {
+        // A frame of four bars around a 50 × 50 gap.
+        let s = [rect(0.0, 0.0, 70.0, 10.0, 0), rect(0.0, 60.0, 70.0, 70.0, 0), rect(0.0, 0.0, 10.0, 70.0, 0), rect(60.0, 0.0, 70.0, 70.0, 0)];
+        let (faces, _) = live_paint(&s);
+        let gap = at(&faces, 35.0, 35.0);
+        assert_eq!(gap.len(), 1);
+        assert!(gap[0].sources.is_empty());
+        assert!((area(gap[0]) - 2500.0).abs() < 1e-6);
+    }
+
+    #[test]
+    fn curves_and_a_circle_crossed_by_a_line() {
+        let circle = Shape::new(shapes::ellipse(Rect::new(0.0, 0.0, 100.0, 100.0)), FillRule::NonZero, 0);
+        let (faces, edges) = live_paint(&[circle, line((-10.0, 50.0), (110.0, 50.0), 1)]);
+        assert_eq!(faces.len(), 2);
+        for f in &faces {
+            assert!((area(f) - std::f64::consts::PI * 2500.0 / 2.0).abs() < 2.0, "{}", area(f));
+            assert!(f.path.subpaths[0].anchors.len() <= 4, "no extra anchors from the sweep's splits");
+        }
+        assert_eq!(edges.iter().filter(|e| e.key == 0).count(), 2, "two arcs");
+    }
+
+    #[test]
+    fn a_line_ending_on_an_edge_splits_the_shape() {
+        let s = [line((90.0, 20.0), (70.0, 10.0), 0), rect(80.0, 10.0, 90.0, 50.0, 1)];
+        let (faces, _) = live_paint(&s);
+        assert_eq!(faces.len(), 2);
+        assert!((area(&faces[0]) + area(&faces[1]) - 400.0).abs() < 1e-6);
+        for f in &faces {
+            let p = crate::interior_point(&f.path).unwrap();
+            assert_eq!(at(&faces, p.x, p.y).len(), 1, "{p:?}");
+            assert_eq!(f.sources, [1]);
+        }
+    }
+
+    #[test]
+    fn nothing_or_garbage_gives_an_empty_map() {
+        assert_eq!(live_paint(&[]), (vec![], vec![]));
+        assert!(live_paint(&[line((0.0, 0.0), (f64::NAN, 1.0), 0)]).0.is_empty());
+        let (faces, edges) = live_paint(&[line((0.0, 0.0), (10.0, 10.0), 0)]);
+        assert!(faces.is_empty());
+        assert_eq!(edges.len(), 1);
+    }
+
+    fn arb_segment() -> impl Strategy<Value = Shape> {
+        let c = || (0..10i32).prop_map(|v| f64::from(v) * 10.0);
+        prop_oneof![
+            (c(), c(), c(), c()).prop_map(|(a, b, x, y)| line((a, b), (x, y), 0)),
+            (c(), c(), 1..5i32, 1..5i32).prop_map(|(x, y, w, h)| rect(x, y, x + f64::from(w) * 10.0, y + f64::from(h) * 10.0, 0)),
+            (c(), c(), 1..5i32).prop_map(|(x, y, r)| {
+                let r = f64::from(r) * 10.0;
+                Shape::new(shapes::ellipse(Rect::new(x, y, x + r, y + r)), FillRule::EvenOdd, 0)
+            }),
+        ]
+    }
+
+    proptest! {
+        #![proptest_config(ProptestConfig { cases: 64, ..ProptestConfig::default() })]
+
+        /// Faces never overlap, and a face's sources are exactly the inputs whose fill holds a
+        /// point inside it.
+        #[test]
+        fn faces_are_disjoint_and_know_what_covers_them(shapes in prop::collection::vec(arb_segment(), 1..7)) {
+            let (faces, _) = live_paint(&shapes);
+            for f in &faces {
+                prop_assert!(area(f) > 0.0);
+                let Some(p) = crate::interior_point(&f.path) else { continue };
+                prop_assert_eq!(faces.iter().filter(|g| g.contains(p)).count(), 1, "{:?} in more than one face", p);
+                let covering: Vec<usize> = shapes
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, s)| s.path.is_closed() && vectorcraft_geom::hit::fill_contains(&s.path.to_bezpath(), s.rule, p))
+                    .map(|(i, _)| i)
+                    .collect();
+                prop_assert_eq!(&f.sources, &covering, "at {:?}", p);
+            }
+        }
+
+        /// Closed shapes alone: the filled faces cover exactly the Pathfinder regions.
+        #[test]
+        fn filled_faces_are_the_pathfinder_regions(shapes in prop::collection::vec(arb_segment(), 1..6)) {
+            let closed: Vec<Shape> = shapes.into_iter().filter(|s| s.path.is_closed()).collect();
+            let (faces, _) = live_paint(&closed);
+            let filled: f64 = faces.iter().filter(|f| !f.sources.is_empty()).map(area).sum();
+            let regions: f64 = crate::regions(&closed).iter().map(|r| area(r).abs()).sum();
+            // Both refit split curves to [`DEFAULT_PRECISION`], so curved areas may differ by up
+            // to that much along every outline.
+            let outlines: f64 = closed.iter().map(|s| s.path.to_bezpath().perimeter(1e-6)).sum();
+            prop_assert!((filled - regions).abs() <= 1e-9 + DEFAULT_PRECISION * outlines, "{} vs {}", filled, regions);
+        }
+
+        /// Lines anywhere (not on a grid): faces stay disjoint, and nothing panics.
+        #[test]
+        fn free_lines_make_disjoint_faces(pts in prop::collection::vec((-50.0..150.0f64, -50.0..150.0f64, -50.0..150.0f64, -50.0..150.0f64), 2..9)) {
+            let lines: Vec<Shape> = pts.into_iter().map(|(a, b, x, y)| line((a, b), (x, y), 0)).collect();
+            let (faces, edges) = live_paint(&lines);
+            prop_assert!(edges.len() >= lines.len().min(1));
+            for f in &faces {
+                prop_assert!(f.sources.is_empty());
+                if let Some(p) = crate::interior_point(&f.path) {
+                    prop_assert_eq!(faces.iter().filter(|g| g.contains(p)).count(), 1);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn many_lines_stay_quick() {
+        // 60 lines through a 100 pt square: about 900 crossings.
+        let lines: Vec<Shape> = (0..60)
+            .map(|k| {
+                let t = f64::from(k) * 0.37;
+                line((50.0 + 80.0 * t.cos(), 50.0 + 80.0 * t.sin()), (50.0 - 80.0 * (t + 1.1).cos(), 50.0 - 80.0 * (t + 1.1).sin()), 0)
+            })
+            .collect();
+        let started = std::time::Instant::now();
+        let (faces, _) = live_paint(&lines);
+        assert!(faces.len() > 500, "{}", faces.len());
+        assert!(started.elapsed().as_secs_f64() < 5.0, "{:?}", started.elapsed());
+    }
+}

crates/pdf/Cargo.toml

@@ -32,4 +32,6 @@ sha2 = { version = "0.10", default-features = false }
 
 [dev-dependencies]
 vectorcraft-testkit = { workspace = true }
+# A variable font built in code (no font file is committed).
+vectorcraft-text = { workspace = true, features = ["test-fonts"] }
 serde_json = { workspace = true }

crates/pdf/src/export.rs

@@ -1444,7 +1444,11 @@ impl Exporter<'_> {
         let name = format!("{} {}", face.family, face.style);
         let font = match face.embedding() {
             Embedding::Subset => {
-                let font = krilla::text::Font::new(face.file_data().to_vec().into(), face.face_index()).map(|f| (f, face.units_per_em()));
+                // A named instance of a variable font is embedded instanced (its own outlines and
+                // widths, not the default instance's).
+                let coords: Vec<(krilla::text::Tag, f32)> = face.variations().iter().map(|(t, v)| (krilla::text::Tag::new(t), *v)).collect();
+                let font =
+                    krilla::text::Font::new_variable(face.file_data().to_vec().into(), face.face_index(), &coords).map(|f| (f, face.units_per_em()));
                 if font.is_none() {
                     self.warn(format!("the font “{name}” can't be embedded: its text is exported as outlines"));
                 }

crates/pdf/src/import.rs

@@ -111,7 +111,16 @@ pub fn import_with_report(bytes: &[u8], opts: &ImportOptions) -> Result<ImportRe
         let scan = scan_page(page, &mut ocgs, all_on, &mut b.fonts);
         b.begin_page(scan);
         interpret_page(page, &mut ctx, &mut b);
-        let parts = b.end_page();
+        let mut parts = b.end_page();
+        // A file with several artboards writes, on each page, the art of its neighbours that
+        // reaches into the page's box: art lying wholly outside this page is theirs (each page
+        // draws it shifted by its own artboard spacing), so keep it only where it belongs.
+        if picked.len() > 1 {
+            for (_, art) in &mut parts {
+                art.retain(|n| n.visual_bounds().is_none_or(|r| r.x0 <= ab.x1 && r.x1 >= ab.x0 && r.y0 <= ab.y1 && r.y1 >= ab.y0));
+            }
+            parts.retain(|(_, art)| !art.is_empty());
+        }
         let children: Vec<Arc<Node>> = parts.iter().flat_map(|(_, v)| v.iter().cloned()).collect();
         placeholder &= crate::pages::has_private_data(page) && only_text(&children);
         let mut right = ab.x1;

crates/pdf/src/import_text.rs

@@ -3,12 +3,15 @@
 //! fifth of the size reads as a space). Fonts are named from the file's base font name (its
 //! subset prefix dropped, the family matched against the fonts available); a font that isn't
 //! available keeps its name, and the text shows in the fallback font until it is.
+//!
+//! Glyphs each turned a little further along a curve (type set on a path: apps write each glyph
+//! with its own placement) make one type-on-a-path object, its path through the glyphs' baseline.
 
 use std::collections::HashMap;
 
-use kurbo::{Affine, Point, Vec2};
+use kurbo::{Affine, BezPath, Point, Vec2};
 use vectorcraft_color::Paint;
-use vectorcraft_doc::{CharStyle, TextObject, TextRun};
+use vectorcraft_doc::{CharStyle, TextKind, TextObject, TextRun};
 
 /// One glyph's placement: its baseline origin, advance direction, size and horizontal scale.
 #[derive(Clone, Copy, Debug)]
@@ -93,12 +96,19 @@ pub(crate) struct TextLine {
     next: Point,
     /// The last glyph's origin.
     last: Point,
+    /// The last glyph's baseline direction.
+    last_dir: Vec2,
+    /// Each glyph's baseline origin, then where the last one ends.
+    baseline: Vec<Point>,
     runs: Vec<(Look, String)>,
 }
 
+/// The most a glyph on a curve turns from the one before it (about 20°).
+const CURVE_TURN_COS: f64 = 0.94;
+
 impl TextLine {
     pub fn new(at: Placement, opacity: f32) -> Self {
-        Self { at, opacity, next: at.origin, last: at.origin, runs: vec![] }
+        Self { at, opacity, next: at.origin, last: at.origin, last_dir: at.dir, baseline: vec![], runs: vec![] }
     }
 
     /// Add glyph `text` drawn with `look` at `at` (advancing `advance` points) at `opacity` if
@@ -106,13 +116,20 @@ impl TextLine {
     pub fn push(&mut self, look: &Look, at: Placement, opacity: f32, advance: f64, text: &str) -> bool {
         if let Some((last, run)) = self.runs.last_mut() {
             let size = self.at.size.max(at.size);
-            let gap = (at.origin - self.next).dot(self.at.dir);
+            let gap = (at.origin - self.next).dot(self.last_dir);
             let on_line = opacity == self.opacity
                 && at.dir.dot(self.at.dir) > 0.9995
                 && (at.origin - self.at.origin).dot(self.at.up()).abs() < size * 0.15
                 && gap > -size * 0.3
                 && gap < size * 3.0;
-            if !on_line {
+            // Or on a curve: turned a little from the glyph before it, and starting about where
+            // that one ends.
+            let on_curve = !on_line
+                && opacity == self.opacity
+                && at.dir.dot(self.last_dir) > CURVE_TURN_COS
+                && at.dir.dot(self.last_dir) < 0.99999
+                && (at.origin - self.next).hypot() < size * 0.6;
+            if !on_line && !on_curve {
                 return false;
             }
             // A gap wider than a fifth of an em reads as a space.
@@ -127,11 +144,42 @@ impl TextLine {
         } else {
             self.runs.push((look.clone(), text.to_string()));
         }
-        self.next = at.origin + self.at.dir * advance;
+        self.next = at.origin + at.dir * advance;
         self.last = at.origin;
+        self.last_dir = at.dir;
+        self.baseline.push(at.origin);
         true
     }
 
+    /// Has the baseline turned (more than about 3° from the first glyph to the last)?
+    fn curved(&self) -> bool {
+        self.last_dir.dot(self.at.dir) < 0.9986
+    }
+
+    /// A smooth path through the glyphs' baseline origins and the end of the last glyph, an em
+    /// further (Catmull-Rom through the points, as cubic Béziers).
+    fn baseline_path(&self) -> Option<BezPath> {
+        let mut pts = self.baseline.clone();
+        // On past the end of the last glyph by an em, so rounding in the spacing doesn't push it
+        // off the end of the path (where type on a path stops).
+        pts.push(self.next);
+        pts.push(self.next + self.last_dir * self.at.size);
+        let first = *pts.first()?;
+        // Finite placements far out can still overflow once an em is added: no path then.
+        if pts.len() < 3 || !pts.iter().all(|p| p.is_finite()) {
+            return None;
+        }
+        let mut bp = BezPath::new();
+        bp.move_to(first);
+        for (i, seg) in pts.windows(2).enumerate() {
+            let &[p1, p2] = seg else { continue };
+            let p0 = *pts.get(i.wrapping_sub(1)).unwrap_or(&p1);
+            let p3 = *pts.get(i + 2).unwrap_or(&p2);
+            bp.curve_to(p1 + (p2 - p0) / 6.0, p2 - (p3 - p1) / 6.0, p2);
+        }
+        Some(bp)
+    }
+
     /// A stroke (`stroke`: paint and width) over the glyph just drawn at `at` in `font` (fill
     /// and stroke rendering): the run is stroked. `false`: it isn't that glyph.
     pub fn stroke_last(&mut self, font: u128, at: Placement, stroke: (Paint, f64)) -> bool {
@@ -144,6 +192,8 @@ impl TextLine {
 
     /// The point type object and its opacity.
     pub fn finish(mut self) -> Option<(TextObject, f32)> {
+        // Turned along a curve: type on a path through the glyphs.
+        let path = if self.curved() { self.baseline_path() } else { None };
         if let Some((_, last)) = self.runs.last_mut() {
             last.truncate(last.trim_end().len());
         }
@@ -156,6 +206,10 @@ impl TextLine {
         let mut t = TextObject::point(Point::ORIGIN, &first.text, first.style);
         t.runs.extend(runs);
         t.xf = Affine::translate(self.at.origin.to_vec2()) * Affine::rotate(self.at.dir.atan2());
+        if let Some(path) = path {
+            t.kind = TextKind::OnPath { path: vectorcraft_geom::PathData::from_bezpath(&path), start: 0.0 };
+            t.xf = Affine::IDENTITY;
+        }
         Some((t, self.opacity))
     }
 }
@@ -206,6 +260,10 @@ impl Families {
             Some((tag, rest)) if tag.len() == 6 && tag.chars().all(|c| c.is_ascii_uppercase()) => rest,
             _ => name,
         };
+        // An installed face of that exact PostScript name: its own family and style.
+        if let Some((family, style)) = vectorcraft_text::FontDb::global().by_postscript_name(name) {
+            return (family, style, true);
+        }
         let (fam, style) = name.split_once(['-', ',']).unwrap_or((name, ""));
         let found = [fam, strip_ps(fam)].iter().find_map(|f| self.0.get(&norm(f)).cloned());
         let style = match spaced(strip_ps(style)).as_str() {

crates/pdf/src/tests_import_fidelity.rs

@@ -359,3 +359,34 @@ fn appearance_items_are_untouched_for_plain_art() {
     assert!(nodes.iter().all(|n| n.mask.is_none() && !matches!(n.kind, NodeKind::Group { .. })));
     assert!(matches!(nodes.iter().find(|n| n.appearance.stroke().is_some()).unwrap().appearance.items[0], AppearanceItem::Stroke(_)));
 }
+
+/// Type set on a path (each glyph placed and turned along a curve, as apps write it) comes back
+/// as type on a path through the glyphs, not as a straight line; straight type stays point type.
+#[test]
+fn glyphs_turned_along_a_curve_become_type_on_a_path() {
+    // "ARCHING" along an arc of radius 100 around (150, 0), each glyph where the one before
+    // it ends (Helvetica's advances), clockwise from 135° (PDF y up: the arc bulges upwards).
+    let mut content = String::from("BT /F1 18 Tf ");
+    let mut a = 135f64.to_radians();
+    for (c, adv) in "ARCHING".chars().zip([667.0, 722.0, 722.0, 722.0, 278.0, 722.0, 778.0]) {
+        let (x, y) = (150.0 + 100.0 * a.cos(), 100.0 * a.sin());
+        // The baseline's direction is the tangent, clockwise along the arc.
+        let (dx, dy) = (a.sin(), -a.cos());
+        content.push_str(&format!("{dx:.5} {dy:.5} {:.5} {dx:.5} {x:.3} {y:.3} Tm ({c}) Tj ", -dy));
+        a -= adv / 1000.0 * 18.0 / 100.0;
+    }
+    content.push_str("ET");
+    let t = texts(&open(&one_page(&content, HELVETICA, &[])));
+    assert_eq!(t.len(), 1, "one text object: {t:?}");
+    let text: String = t[0].runs.iter().map(|r| r.text.as_str()).collect();
+    assert_eq!(text, "ARCHING");
+    let vectorcraft_doc::TextKind::OnPath { path, .. } = &t[0].kind else { panic!("type on a path: {:?}", t[0].kind) };
+    let b = path.bounds().unwrap();
+    assert!(b.height() > 15.0, "the path curves: {b:?}");
+    // Every glyph fits on the path, the last one too.
+    assert_eq!(vectorcraft_text::layout(vectorcraft_text::FontDb::global(), &t[0]).glyphs.len(), 7);
+    // Straight type with a slight rotation stays one point type object.
+    let straight = texts(&open(&one_page("BT /F1 18 Tf 0.98481 0.17365 -0.17365 0.98481 20 40 Tm (Straight) Tj ET", HELVETICA, &[])));
+    assert_eq!(straight.len(), 1);
+    assert!(matches!(straight[0].kind, vectorcraft_doc::TextKind::Point), "{:?}", straight[0].kind);
+}

crates/pdf/src/tests_import_options.rs

@@ -106,6 +106,19 @@ fn bounding_boxes_of_several_pages_do_not_overlap() {
     assert!(b.x0 >= a.x1 + 36.0, "{a:?} {b:?}");
 }
 
+#[test]
+fn art_of_neighbouring_artboards_off_a_page_is_left_to_its_own_page() {
+    // Page 2 also draws page 1's square, off to its left (outside its box), as files with several
+    // artboards are written: only page 1 keeps it, so it doesn't come back twice.
+    let pages = [PdfPage::new(100.0, 100.0, "0 g 10 10 20 20 re f"), PdfPage::new(100.0, 100.0, "0 g -90 10 20 20 re f 1 0 0 rg 50 10 20 20 re f")];
+    let d = open(&pdf(&pages, None), ImportOptions::default());
+    let count = |i: usize| d.layers[i].children().map_or(0, |c| c.len());
+    assert_eq!((count(0), count(1)), (1, 1));
+    // A single page keeps its art off the page (the pasteboard).
+    let d = open(&pdf(&pages[1..], None), ImportOptions::default());
+    assert_eq!(d.layers[0].children().map_or(0, |c| c.len()), 2);
+}
+
 #[test]
 fn an_encrypted_pdf_opens_with_its_password_only() {
     let bytes = pdf(&[PdfPage::new(200.0, 100.0, "1 0 0 rg 10 10 50 50 re f")], Some("secret"));

crates/pdf/src/tests_realtext.rs

@@ -110,6 +110,28 @@ fn real_text_lands_within_half_a_point_of_the_outlines() {
     }
 }
 
+/// A named instance of a variable font is real text in that instance: its embedded subset draws
+/// the instance's glyphs where the outlines would be, not the default instance's (#296).
+#[test]
+fn variable_font_instances_are_real_text_in_their_own_glyphs() {
+    use vectorcraft_text::test_fonts::{VARIABLE_CHARS, VARIABLE_FAMILY, variable_font};
+    FontDb::global().add_font(variable_font().unwrap());
+    let mut widths = vec![];
+    for s in ["Regular", "Bold"] {
+        let st = CharStyle { font_family: VARIABLE_FAMILY.into(), font_style: s.into(), ..style(48.0) };
+        let d = doc(vec![TextObject::point(Point::new(20.0, 80.0), VARIABLE_CHARS, st)]);
+        let r = pdf(&d, false);
+        assert!(r.warnings.is_empty(), "{s}: {:?}", r.warnings);
+        assert_eq!(texts(&import_as(&r.bytes, TextAs::Text)), [VARIABLE_CHARS], "{s}: real text");
+        let (real, outlined) = (ink(&import_as(&r.bytes, TextAs::Outlines)), ink(&import_as(&pdf(&d, true).bytes, TextAs::Outlines)));
+        let off =
+            [real.x0 - outlined.x0, real.y0 - outlined.y0, real.x1 - outlined.x1, real.y1 - outlined.y1].iter().fold(0.0f64, |m, v| m.max(v.abs()));
+        assert!(off < 0.5, "{s}: {real:?} vs {outlined:?}");
+        widths.push(real.width());
+    }
+    assert!(widths[1] > widths[0] * 1.2, "Bold is wider: {widths:?}");
+}
+
 #[test]
 fn gradients_on_real_text_stay_where_they_were() {
     let fill = Paint::Gradient(Box::new(GradientPaint::new(Gradient::default())));

crates/render/src/lib.rs

@@ -1488,8 +1488,14 @@ fn text_geom_snapped(t: &TextObject, snap: Option<Affine>) -> TextGeom {
     let mut runs = vec![BezPath::new(); t.runs.len()];
     let mut all = BezPath::new();
     // Per run: is its family missing, and the face its glyphs should come from.
-    let faces: Vec<(bool, Option<u32>)> =
-        t.runs.iter().map(|r| (!db.has_family(&r.style.font_family), db.face(&r.style.font_family, &r.style.font_style).map(|f| f.id()))).collect();
+    let faces: Vec<(bool, Option<u32>)> = t
+        .runs
+        .iter()
+        .map(|r| match db.resolve(&r.style.font_family, &r.style.font_style) {
+            Some((f, m)) => (m == vectorcraft_text::FontMatch::Missing, Some(f.id())),
+            None => (true, None),
+        })
+        .collect();
     let (mut substituted_fonts, mut substituted_glyphs) = (BezPath::new(), BezPath::new());
     for g in &layout.glyphs {
         if let Some(r) = runs.get_mut(g.run) {

crates/svg/Cargo.toml

@@ -30,6 +30,8 @@ svgtypes = "0.16"
 [dev-dependencies]
 # Reading embedded font subsets back.
 skrifa = { workspace = true }
+# A variable font built in code (no font file is committed).
+vectorcraft-text = { workspace = true, features = ["test-fonts"] }
 resvg = { version = "0.45", default-features = false }
 vectorcraft-testkit = { workspace = true }
 proptest = { workspace = true }

crates/svg/src/export.rs

@@ -1576,7 +1576,7 @@ impl Writer<'_> {
     /// as the canvas paints them, the object's own fills and strokes on the glyph outlines: those
     /// below the Characters row under the characters, the others over them.
     fn text_node(&mut self, n: &Node, t: &TextObject) {
-        let chars = |w: &mut Self, n: &Node| if w.opts.outline_text { w.text_outlines(n, t) } else { w.text(n, t) };
+        let chars = |w: &mut Self, n: &Node| if w.opts.outline_text || t.vertical { w.text_outlines(n, t) } else { w.text(n, t) };
         if !n.appearance.items.iter().any(|i| i.visible() && !i.paint().is_none()) {
             return chars(self, n);
         }

crates/svg/tests/encoding_profile_fonts.rs

@@ -216,6 +216,31 @@ fn embedded_fonts_hold_only_the_glyphs_used() {
     assert!(!export_full(&d, &ExportOptions { embed_fonts: true, outline_text: true, ..Default::default() }, None).svg.contains("@font-face"));
 }
 
+/// A named instance of a variable font embeds as a static font of that instance: the variable
+/// file would show its default instance in browsers (#296).
+#[test]
+fn variable_font_instances_embed_as_themselves() {
+    use vectorcraft_text::test_fonts::{VARIABLE_FAMILY, variable_font};
+    let db = vectorcraft_text::FontDb::global();
+    db.add_font(variable_font().unwrap());
+    let mut d = Document::new(300.0, 200.0);
+    add(&mut d, text(Point::new(20.0, 60.0), &[("ll", style(VARIABLE_FAMILY, "Regular")), ("ll", style(VARIABLE_FAMILY, "Bold"))]));
+    let o = export_full(&d, &ExportOptions { embed_fonts: true, ..Default::default() }, None);
+    let fonts = embedded(&o.svg);
+    assert_eq!(fonts.iter().map(|f| f.1).collect::<Vec<_>>(), [400, 700], "{:?}", o.warnings);
+    let mut advances = vec![];
+    for ((_, w, data), style) in fonts.iter().zip(["Regular", "Bold"]) {
+        let f = skrifa::FontRef::new(data).unwrap();
+        assert!(f.fvar().is_err() && f.gvar().is_err(), "{w}: a static font");
+        let gid = f.cmap().unwrap().map_codepoint('l').unwrap();
+        let adv = f.hmtx().unwrap().advance(gid).unwrap();
+        let face = db.face(VARIABLE_FAMILY, style).unwrap();
+        assert_eq!(f64::from(adv), face.advance(face.glyph_for('l')).round(), "{style}");
+        advances.push(adv);
+    }
+    assert!(advances[1] > advances[0], "{advances:?}");
+}
+
 /// The bundled Source Sans 3 Regular renamed `family` (13 characters, as long as the original
 /// name) with OS/2 `fsType` set to `fs_type`.
 fn licensed_font(family: &str, fs_type: u16) -> Vec<u8> {

crates/text/Cargo.toml

@@ -15,5 +15,16 @@ kurbo = { workspace = true }
 skrifa = { workspace = true }
 harfrust = { workspace = true }
 log = { workspace = true }
-# Font subsets for embedding (SVG @font-face); MIT OR Apache-2.0, already used by the PDF writer.
-subsetter = { version = "0.2", default-features = false }
+# Font subsets for embedding (SVG @font-face); MIT OR Apache-2.0, already used by the PDF writer
+# (which turns on `variable-fonts` too: named instances of variable fonts are instanced).
+subsetter = { version = "0.2", default-features = false, features = ["variable-fonts"] }
+# Builds a small variable font for tests (`test_fonts`; no font file is committed). MIT OR
+# Apache-2.0, already in the build through subsetter.
+write-fonts = { version = "0.48", optional = true }
+
+[features]
+# `vectorcraft_text::test_fonts` for other crates' tests (dev-dependencies only).
+test-fonts = ["dep:write-fonts"]
+
+[dev-dependencies]
+write-fonts = "0.48"

crates/text/build.rs

@@ -0,0 +1,74 @@
+//! The optional craft-fonts build input (https://github.com/storytold/craft-fonts,
+//! `docs/integration.md`): with `CRAFT_FONTS_DIR=<checkout>` set, every font in its
+//! `fonts/manifest.txt` is embedded as `CRAFT_FONTS`; unset, `CRAFT_FONTS` is empty and the app
+//! uses its own and the installed fonts. `CRAFT_FONTS_REQUIRED=1` turns a bad checkout into a build
+//! error (release builds). Nothing is fetched: the build reads only the local checkout.
+//!
+//! Web (wasm32) builds embed only the UI font, BIZ UDPGothic Regular (~4.7 MB): the browser has no
+//! system fonts, and all four fonts (~24 MB) would push the `.wasm` past static hosts' per-file
+//! limits (Cloudflare Pages: 25 MiB).
+
+use std::fmt::Write as _;
+use std::path::{Path, PathBuf};
+
+fn main() {
+    println!("cargo::rerun-if-env-changed=CRAFT_FONTS_DIR");
+    println!("cargo::rerun-if-env-changed=CRAFT_FONTS_REQUIRED");
+    let mut src = String::from("pub static CRAFT_FONTS: &[CraftFont] = &[\n");
+    if let Some(dir) = std::env::var_os("CRAFT_FONTS_DIR").map(PathBuf::from) {
+        let dir = from_workspace(dir);
+        match craft_fonts(&dir) {
+            Ok(entries) => src.push_str(&entries),
+            Err(e) if std::env::var_os("CRAFT_FONTS_REQUIRED").is_some() => {
+                println!("cargo::error=CRAFT_FONTS_DIR={}: {e}", dir.display());
+            }
+            Err(e) => println!("cargo::warning=building without craft-fonts: CRAFT_FONTS_DIR={}: {e}", dir.display()),
+        }
+    }
+    src.push_str("];\n");
+    let out = PathBuf::from(std::env::var_os("OUT_DIR").unwrap_or_default()).join("craft_fonts.rs");
+    if let Err(e) = std::fs::write(&out, src) {
+        println!("cargo::error=writing {}: {e}", out.display());
+    }
+}
+
+/// A relative `CRAFT_FONTS_DIR` is taken from the workspace root (where `cargo` is usually run),
+/// not from this crate's directory, which is where build scripts run.
+fn from_workspace(dir: PathBuf) -> PathBuf {
+    if dir.is_absolute() {
+        return dir;
+    }
+    let crate_dir = PathBuf::from(std::env::var_os("CARGO_MANIFEST_DIR").unwrap_or_default());
+    crate_dir.join("../..").join(dir)
+}
+
+/// The one craft-fonts face web builds embed (family, style).
+const WEB_FONT: (&str, &str) = ("BIZ UDPGothic", "Regular");
+
+/// One `CraftFont { .. }` initialiser per manifest line.
+fn craft_fonts(dir: &Path) -> Result<String, String> {
+    let manifest = dir.join("fonts/manifest.txt");
+    println!("cargo::rerun-if-changed={}", manifest.display());
+    let text = std::fs::read_to_string(&manifest).map_err(|e| format!("{}: {e}", manifest.display()))?;
+    let wasm = std::env::var("CARGO_CFG_TARGET_ARCH").is_ok_and(|a| a == "wasm32");
+    let mut out = String::new();
+    for line in text.lines().map(str::trim).filter(|l| !l.is_empty() && !l.starts_with('#')) {
+        let f: Vec<&str> = line.split(" | ").map(str::trim).collect();
+        let [family, style, file, scripts, ..] = f.as_slice() else {
+            return Err(format!("malformed manifest line: {line}"));
+        };
+        if wasm && !(*family == WEB_FONT.0 && *style == WEB_FONT.1) {
+            continue;
+        }
+        let path = dir.join(file).canonicalize().map_err(|e| format!("{file}: {e}"))?;
+        println!("cargo::rerun-if-changed={}", path.display());
+        let scripts: Vec<String> = scripts.split(',').map(|s| format!("{:?}", s.trim())).collect();
+        let _ = writeln!(
+            out,
+            "    CraftFont {{ family: {family:?}, style: {style:?}, scripts: &[{}], bytes: include_bytes!({:?}) }},",
+            scripts.join(", "),
+            path.display().to_string(),
+        );
+    }
+    Ok(out)
+}

crates/text/src/craft_fonts.rs

@@ -0,0 +1,52 @@
+//! Fonts from the optional craft-fonts build input (<https://github.com/storytold/craft-fonts>).
+//!
+//! Built with `CRAFT_FONTS_DIR=<craft-fonts checkout>`, [`CRAFT_FONTS`] holds every font in its
+//! manifest (today the Japanese UI and document fonts); built without it, it is empty and Japanese
+//! text falls back to the installed system fonts. Release builds always set it. See `build.rs`
+//! and craftrules `standards/fonts.md`.
+
+/// A font from the optional craft-fonts build input (empty unless built with `CRAFT_FONTS_DIR`).
+pub struct CraftFont {
+    pub family: &'static str,
+    pub style: &'static str,
+    /// ISO 15924 scripts the font is for, e.g. `"Jpan"`.
+    pub scripts: &'static [&'static str],
+    pub bytes: &'static [u8],
+}
+
+include!(concat!(env!("OUT_DIR"), "/craft_fonts.rs"));
+
+impl CraftFont {
+    /// Is the font for Japanese text?
+    pub fn is_japanese(&self) -> bool {
+        self.scripts.contains(&"Jpan")
+    }
+    /// A serif (Mincho) family, for document text.
+    pub fn is_mincho(&self) -> bool {
+        self.family.contains("Mincho")
+    }
+    /// A sans (Gothic) family, for UI text.
+    pub fn is_gothic(&self) -> bool {
+        self.family.contains("Gothic")
+    }
+    /// A bold face.
+    pub fn is_bold(&self) -> bool {
+        crate::style_weight(self.style) >= 600.0
+    }
+}
+
+/// The craft-fonts faces for Japanese text, best for document text first: Mincho (serif) families,
+/// then the others, regular weights before bold. Empty when built without craft-fonts.
+pub fn japanese_document_fonts() -> Vec<&'static CraftFont> {
+    let mut v: Vec<&'static CraftFont> = CRAFT_FONTS.iter().filter(|f| f.is_japanese()).collect();
+    v.sort_by_key(|f| (!f.is_mincho(), f.is_bold()));
+    v
+}
+
+/// The craft-fonts faces for Japanese text, best for UI text first: Gothic (sans) families, then
+/// the others; `bold` puts bold faces before regular ones. Empty when built without craft-fonts.
+pub fn japanese_ui_fonts(bold: bool) -> Vec<&'static CraftFont> {
+    let mut v: Vec<&'static CraftFont> = CRAFT_FONTS.iter().filter(|f| f.is_japanese()).collect();
+    v.sort_by_key(|f| (!f.is_gothic(), f.is_bold() != bold));
+    v
+}

crates/text/src/embed.rs

@@ -60,19 +60,29 @@ impl FontFace {
 
     /// The face as a font file to embed: the glyphs of `chars` alone when its licence allows
     /// subsetting, else the whole face. Ligatures, kerning and other layout features are left out
-    /// of subsets (viewers draw each character's own glyph). `None` when the licence forbids
-    /// embedding or the font can't be read.
+    /// of subsets (viewers draw each character's own glyph). A named instance of a variable font
+    /// ([`FontFace::variations`]) is embedded as a static font of that instance (the variable file
+    /// would show its default instance), CFF2 outlines becoming TrueType ones. `None` when the
+    /// licence forbids embedding or the font can't be read.
     pub fn embed(&self, chars: &[char]) -> Option<EmbeddedFont> {
         let font = self.skrifa()?;
         let cff = [b"CFF ", b"CFF2"].iter().any(|t| font.table_data(Tag::new(t)).is_some());
         let whole = || Some(EmbeddedFont { data: sfnt(font.table_directory.sfnt_version(), tables(&font))?, cff, subset: false });
+        let instance = !self.variations().is_empty();
         match self.embedding() {
             Embedding::Forbidden => None,
+            // Every glyph of the instance, keeping their ids.
+            Embedding::Whole if instance => {
+                let all: Vec<char> = font.charmap().mappings().filter_map(|(c, _)| char::from_u32(c)).collect();
+                subset(self, &font, &all, true).map(|(data, cff)| EmbeddedFont { data, cff, subset: false })
+            }
             Embedding::Whole => whole(),
-            Embedding::Subset => match subset(self, &font, chars) {
-                Some(data) => Some(EmbeddedFont { data, cff, subset: true }),
-                // Outlines the subsetter can't read (CFF2): what the licence allows anyway.
-                None => whole(),
+            Embedding::Subset => match subset(self, &font, chars, false) {
+                Some((data, cff)) => Some(EmbeddedFont { data, cff, subset: true }),
+                // Outlines the subsetter can't read: what the licence allows anyway (a named
+                // instance can't be embedded whole, which would show the default instance).
+                None if !instance => whole(),
+                None => None,
             },
         }
     }
@@ -83,10 +93,17 @@ fn tables<'a>(font: &skrifa::FontRef<'a>) -> Vec<(Tag, Cow<'a, [u8]>)> {
     font.table_directory.table_records().iter().filter_map(|r| font.table_data(r.tag()).map(|d| (r.tag(), Cow::Borrowed(d.as_bytes())))).collect()
 }
 
-/// `face` reduced to the glyphs of `chars`, with a `cmap` mapping them and the face's `OS/2`.
-fn subset(face: &FontFace, font: &skrifa::FontRef<'_>, chars: &[char]) -> Option<Vec<u8>> {
+/// `face` reduced to the glyphs of `chars` (every glyph, keeping their ids, when `all`), with a
+/// `cmap` mapping them and the face's `OS/2`; a named instance instanced. Returns the font and
+/// whether its outlines are CFF ones.
+fn subset(face: &FontFace, font: &skrifa::FontRef<'_>, chars: &[char], all: bool) -> Option<(Vec<u8>, bool)> {
     let charmap = font.charmap();
     let mut remapper = subsetter::GlyphRemapper::new();
+    if all {
+        for gid in 0..font.maxp().ok()?.num_glyphs() {
+            remapper.remap(gid);
+        }
+    }
     let mut map: Vec<(u32, u16)> = chars
         .iter()
         .filter_map(|c| {
@@ -96,14 +113,20 @@ fn subset(face: &FontFace, font: &skrifa::FontRef<'_>, chars: &[char]) -> Option
         .collect();
     map.sort_unstable();
     map.dedup_by_key(|m| m.0);
-    let data = subsetter::subset(face.data(), face.index(), &remapper).ok()?;
+    let data = if face.variations().is_empty() {
+        subsetter::subset(face.data(), face.index(), &remapper).ok()?
+    } else {
+        let coords: Vec<(subsetter::Tag, f32)> = face.variations().iter().map(|(t, v)| (subsetter::Tag::new(t), *v)).collect();
+        subsetter::subset_with_variations(face.data(), face.index(), &coords, &remapper).ok()?
+    };
     let sub = skrifa::FontRef::new(&data).ok()?;
+    let cff = [b"CFF ", b"CFF2"].iter().any(|t| sub.table_data(Tag::new(t)).is_some());
     let mut t: Vec<(Tag, Cow<'_, [u8]>)> = tables(&sub).into_iter().filter(|(tag, _)| *tag != CMAP && *tag != OS2).collect();
     t.push((CMAP, Cow::Owned(cmap(&map)?)));
     if let Some(os2) = font.table_data(OS2) {
         t.push((OS2, Cow::Owned(os2_for(os2.as_bytes(), &map))));
     }
-    sfnt(sub.table_directory.sfnt_version(), t)
+    Some((sfnt(sub.table_directory.sfnt_version(), t)?, cff))
 }
 
 /// The face's `OS/2` table with its first and last character fitted to the subset's.

crates/text/src/features.rs

@@ -7,6 +7,8 @@ use vectorcraft_doc::CharStyle;
 /// by the character style (`kerning`, `all_caps`, `tracking`); the rest are layout-wide options.
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub struct OtFeatures {
+    /// Vertical glyph alternates (`vert`), set by the writing direction.
+    pub vertical: bool,
     /// Standard ligatures (`liga`, `clig`). Suppressed automatically when tracking is non-zero.
     pub ligatures: bool,
     /// Contextual alternates (`calt`).
@@ -30,6 +32,7 @@ pub struct OtFeatures {
 impl Default for OtFeatures {
     fn default() -> Self {
         Self {
+            vertical: false,
             ligatures: true,
             contextual: true,
             discretionary_ligatures: false,
@@ -138,6 +141,11 @@ impl OtFeatures {
                 v.push(f(tag, true));
             }
         }
+        if self.vertical {
+            // Not `vrt2`: its glyphs are already turned on their side, and the layout turns Latin
+            // and digits itself (they would lie upside down, and tate-chu-yoko break).
+            v.push(f(b"vert", true));
+        }
         v
     }
 }

crates/text/src/fontdb.rs

@@ -7,11 +7,11 @@ use std::sync::atomic::{AtomicU32, AtomicU64, Ordering};
 use std::sync::{Arc, Mutex, RwLock};
 
 use kurbo::BezPath;
-use skrifa::instance::{LocationRef, Size};
+use skrifa::instance::{Location, LocationRef, Size};
 use skrifa::outline::{DrawSettings, OutlinePen};
 use skrifa::raw::FileRef;
 use skrifa::string::StringId;
-use skrifa::{GlyphId, MetadataProvider};
+use skrifa::{GlyphId, MetadataProvider, Tag};
 
 /// The family used when a requested family is unknown (Illustrator's Myriad Pro analogue).
 pub const FALLBACK_FAMILY: &str = "Source Sans 3";
@@ -28,6 +28,14 @@ static BUNDLED: &[&[u8]] = &[
     include_bytes!("../../../assets/fonts/JetBrainsMono-Regular.ttf"),
 ];
 
+/// An axis setting of a variable font: the axis tag (`wght`) and its value in user units (700).
+pub type Variation = ([u8; 4], f32);
+
+/// Caps on what a (possibly damaged) variable font can make the database read: axes per font and
+/// named instances listed per face.
+const MAX_AXES: usize = 64;
+const MAX_INSTANCES: usize = 512;
+
 enum FontBytes {
     Static(&'static [u8]),
     Owned(Arc<Vec<u8>>),
@@ -35,6 +43,8 @@ enum FontBytes {
 
 /// One loaded font face.
 pub struct FontFace {
+    /// Every name the face answers to (normalized), in every language its name table has.
+    keys: FaceKeys,
     id: u32,
     /// Typographic family name (e.g. "Source Sans 3").
     pub family: String,
@@ -58,6 +68,13 @@ pub struct FontFace {
     pub(crate) cap_height: f64,
     pub(crate) x_height: f64,
     pub(crate) shaper: harfrust::ShaperData,
+    /// The axis settings of the variable font's named instance this face is (user units: `wght`
+    /// 700); empty for a static face or a variable font's default instance.
+    variations: Vec<Variation>,
+    /// [`Self::variations`] in the font's normalized design space (outlines and metrics).
+    location: Location,
+    /// [`Self::variations`] for the shaper (advances, kerning, feature variations).
+    pub(crate) instance: Option<harfrust::ShaperInstance>,
 }
 
 impl std::fmt::Debug for FontFace {
@@ -83,6 +100,17 @@ impl FontFace {
     pub(crate) fn index(&self) -> u32 {
         self.index
     }
+    /// Where in a variable font's design space the face's outlines and metrics are taken (the
+    /// default location for a static face).
+    pub(crate) fn location(&self) -> LocationRef<'_> {
+        LocationRef::from(&self.location)
+    }
+    /// The axis settings of the variable font's named instance this face is (`wght` 700 for
+    /// Bold), in user units; empty for a static face and a variable font's default instance.
+    /// The face's file holds the whole variable font: exporters that embed it pass these on.
+    pub fn variations(&self) -> &[Variation] {
+        &self.variations
+    }
     /// Unique id of this face within the process.
     pub fn id(&self) -> u32 {
         self.id
@@ -110,7 +138,7 @@ impl FontFace {
     /// Advance width of glyph `gid` in font units.
     pub fn advance(&self, gid: u32) -> f64 {
         self.skrifa()
-            .and_then(|f| f.glyph_metrics(Size::unscaled(), LocationRef::default()).advance_width(GlyphId::new(gid)))
+            .and_then(|f| f.glyph_metrics(Size::unscaled(), self.location()).advance_width(GlyphId::new(gid)))
             .map(|a| a as f64)
             .unwrap_or(self.upem * 0.5)
     }
@@ -145,28 +173,46 @@ impl FontFace {
 #[derive(Debug, Default)]
 struct CatalogFamily {
     name: String,
-    /// (style, file) of each face.
-    faces: Vec<(String, PathBuf)>,
+    faces: Vec<CatalogFace>,
+}
+
+/// One style of an installed family: a face, or a named instance of a variable font.
+#[derive(Debug)]
+#[cfg_attr(target_arch = "wasm32", allow(dead_code))]
+struct CatalogFace {
+    style: String,
+    path: PathBuf,
+    /// Weight and italic as the style lists them (by its name, or a named instance's axes).
+    weight: f32,
+    italic: bool,
 }
 
 /// The installed fonts by ASCII-lowercased family name (lookups ignore ASCII case, as
 /// [`FontDb::face`] does). Always empty on wasm, which has no system fonts.
 type Catalog = HashMap<String, CatalogFamily>;
 
+/// The installed faces' (family, style) by normalized PostScript name ([`norm`]).
+type PostScriptNames = HashMap<String, (String, String)>;
+
 /// Process-wide font database.
 pub struct FontDb {
     faces: RwLock<Vec<Arc<FontFace>>>,
     outlines: Mutex<HashMap<(u32, u32), Arc<BezPath>>>,
     catalog: RwLock<Catalog>,
+    /// The installed faces by PostScript name (documents name fonts so: PDF, EPS, .ai).
+    postscript: RwLock<PostScriptNames>,
     /// 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<PathBuf>,
+    /// The installed fonts' other names (localized, legacy, PostScript) by normalized name.
+    aliases: RwLock<HashMap<String, Vec<Alias>>>,
     /// Set once the font folders have been scanned. Lookups by family name wait for the first
     /// scan, so what they find never depends on what ran before them.
     #[cfg(not(target_arch = "wasm32"))]
     cataloged: std::sync::OnceLock<()>,
     /// [`FontDb::family_list`], built on demand and dropped when fonts are added or rescanned.
     family_cache: Mutex<Option<Arc<[String]>>>,
+    menu_cache: Mutex<Option<MenuFamilies>>,
     generation: AtomicU64,
     /// System fallback state: characters no system font covers.
     #[cfg(not(target_arch = "wasm32"))]
@@ -217,6 +263,116 @@ 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()))
 }
 
+/// Every localized string of `id`, with its language.
+fn localized(font: &skrifa::FontRef<'_>, id: StringId) -> Vec<(Option<String>, String)> {
+    font.localized_strings(id).map(|s| (s.language().map(str::to_owned), s.to_string())).filter(|(_, s)| !s.is_empty()).collect()
+}
+
+/// Every localized string of `id`.
+fn all_names(font: &skrifa::FontRef<'_>, id: StringId) -> Vec<String> {
+    localized(font, id).into_iter().map(|(_, s)| s).collect()
+}
+
+/// The names a face answers to besides its (English) family and style, normalized ([`norm`]):
+/// its family in every language (typographic, else legacy: `ヒラギノ角ゴシック`), its style likewise
+/// (`ミディアム`), its legacy family names (`Hiragino Sans W3`) with their legacy styles, paired per
+/// language record (the Mac and Windows records of a face differ), and its PostScript names
+/// (`HiraginoSans-W3`, as PDF and `.ai` files name fonts).
+#[derive(Clone, Debug, Default)]
+struct FaceKeys {
+    families: Vec<String>,
+    styles: Vec<String>,
+    legacy: Vec<(String, String)>,
+    postscript: Vec<String>,
+}
+
+impl FaceKeys {
+    fn of(font: &skrifa::FontRef<'_>, family: &str, style: &str) -> Self {
+        let (typo_family, typo_style) = (all_names(font, StringId::TYPOGRAPHIC_FAMILY_NAME), all_names(font, StringId::TYPOGRAPHIC_SUBFAMILY_NAME));
+        let (legacy_family, legacy_style) = (localized(font, StringId::FAMILY_NAME), localized(font, StringId::SUBFAMILY_NAME));
+        // Without typographic names, the legacy ones are the family's.
+        let family_names: Vec<&str> = if typo_family.is_empty() {
+            legacy_family.iter().map(|(_, f)| f.as_str()).collect()
+        } else {
+            typo_family.iter().map(String::as_str).collect()
+        };
+        let mut families: Vec<String> = std::iter::once(family).chain(family_names).map(norm).collect();
+        // A legacy style only names the face beside its legacy family when the font has a
+        // typographic style: every weight of `Hiragino Sans` is `Regular` in its own legacy family.
+        let style_names: Vec<&str> = if typo_style.is_empty() {
+            legacy_style.iter().map(|(_, s)| s.as_str()).collect()
+        } else {
+            typo_style.iter().map(String::as_str).collect()
+        };
+        let mut styles: Vec<String> = std::iter::once(style).chain(style_names).map(norm).collect();
+        let mut legacy: Vec<(String, String)> = if typo_family.is_empty() {
+            vec![]
+        } else {
+            legacy_family
+                .iter()
+                .flat_map(|(lf, f)| legacy_style.iter().filter(move |(ls, _)| ls == lf).map(move |(_, s)| (norm(f), norm(s))))
+                .filter(|(f, s)| !f.is_empty() && !s.is_empty())
+                .collect()
+        };
+        let mut postscript: Vec<String> = all_names(font, StringId::POSTSCRIPT_NAME).iter().map(|n| norm(n)).collect();
+        for v in [&mut families, &mut styles, &mut postscript] {
+            v.retain(|k| !k.is_empty());
+            v.sort();
+            v.dedup();
+        }
+        legacy.sort();
+        legacy.dedup();
+        FaceKeys { families, styles, legacy, postscript }
+    }
+}
+
+/// What a name other than a family's own one stands for ([`FontDb::canonical`]).
+#[derive(Clone, Debug)]
+struct Alias {
+    /// The family's own name.
+    family: String,
+    /// The face the name names, for legacy family names and PostScript names.
+    style: Option<String>,
+    /// A legacy family name's legacy style (`Regular` beside `Hiragino Sans W3`).
+    paired: Option<String>,
+}
+
+impl Alias {
+    /// The aliases of a face `family` / `style` with `keys`, by normalized name.
+    fn of(family: &str, style: &str, keys: &FaceKeys) -> Vec<(String, Alias)> {
+        let mut v: Vec<(String, Alias)> =
+            keys.families.iter().map(|k| (k.clone(), Alias { family: family.to_string(), style: None, paired: None })).collect();
+        v.extend(
+            keys.legacy
+                .iter()
+                .map(|(f, s)| (f.clone(), Alias { family: family.to_string(), style: Some(style.to_string()), paired: Some(s.clone()) })),
+        );
+        v.extend(keys.postscript.iter().map(|k| (k.clone(), Alias { family: family.to_string(), style: Some(style.to_string()), paired: None })));
+        v
+    }
+}
+
+/// How a requested family and style resolved ([`FontDb::resolve`]).
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum FontMatch {
+    /// The face of that family and style (by any of its names, in any language).
+    Exact,
+    /// The family is there but not the style: its closest style stands in.
+    Style,
+    /// The family is unknown: the fallback family stands in.
+    Missing,
+}
+
+impl FontMatch {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            FontMatch::Exact => "exact",
+            FontMatch::Style => "substitute",
+            FontMatch::Missing => "missing",
+        }
+    }
+}
+
 /// A face's (family, style) names.
 fn face_names(f: &skrifa::FontRef<'_>) -> Option<(String, String)> {
     let family = name(f, &[StringId::TYPOGRAPHIC_FAMILY_NAME, StringId::FAMILY_NAME])?;
@@ -224,25 +380,103 @@ fn face_names(f: &skrifa::FontRef<'_>) -> Option<(String, String)> {
     Some((family, style))
 }
 
-/// Parse every face in `data` (a font file or collection). Returns `(index, family, style)`.
-fn enumerate_faces(data: &[u8]) -> Vec<(u32, String, String)> {
+/// One style a font file offers: one of its faces, or a named instance of a variable font
+/// (Figtree's `Figtree[wght].ttf` holds Light, the default, and Regular to Black as instances).
+#[derive(Clone, Debug)]
+pub(crate) struct FaceStyle {
+    family: String,
+    style: String,
+    keys: FaceKeys,
+    /// A named instance's axis settings (user units); empty for the face itself.
+    variations: Vec<Variation>,
+    /// A named instance's weight (its `wght` setting); `None` for the face itself (its OS/2 table
+    /// says) or an instance of a font without a weight axis.
+    weight: Option<f32>,
+    /// A named instance is italic (by its `ital` or `slnt` setting, or its name).
+    italic: bool,
+}
+
+/// The styles of a face: the face itself, then its named instances when it is a variable font.
+pub(crate) fn face_styles(f: &skrifa::FontRef<'_>) -> Vec<FaceStyle> {
+    let Some((family, style)) = face_names(f) else { return vec![] };
+    let mut keys = FaceKeys::of(f, &family, &style);
+    let instances = named_instances(f, &family, &style, &mut keys);
+    let face = FaceStyle { family, style, keys, variations: vec![], weight: None, italic: false };
+    std::iter::once(face).chain(instances).collect()
+}
+
+/// The named instances of a variable font face (its `fvar` table) as styles of the face's family,
+/// named by their subfamily names, without the default instance (the face itself) and without
+/// names already taken. The default instance's name, when it isn't the face's style name (a face
+/// `Regular` whose default instance is `Book`), names the face too (`keys`). Damaged tables give
+/// fewer instances or none; the counts read are capped.
+fn named_instances(f: &skrifa::FontRef<'_>, family: &str, style: &str, keys: &mut FaceKeys) -> Vec<FaceStyle> {
+    let axes = f.axes();
+    if axes.is_empty() || axes.len() > MAX_AXES {
+        return vec![];
+    }
+    let tags: Vec<Tag> = axes.iter().map(|a| a.tag()).collect();
+    let defaults: Vec<f32> = axes.iter().map(|a| a.default_value()).collect();
+    // Instances without a PostScript name of their own are named `<prefix>-<style>` (Adobe
+    // Technical Note #5902), as PDF and `.ai` files name them.
+    let prefix = name(f, &[StringId::VARIATIONS_POSTSCRIPT_NAME_PREFIX]).unwrap_or_else(|| family.to_string());
+    let mut taken = vec![norm(style)];
+    let mut out = Vec::new();
+    for inst in f.named_instances().iter().take(MAX_INSTANCES) {
+        let coords: Vec<f32> = inst.user_coords().take(MAX_AXES).collect();
+        if coords.len() != tags.len() || coords.iter().any(|c| !c.is_finite()) {
+            continue;
+        }
+        let Some(style) = name(f, &[inst.subfamily_name_id()]) else { continue };
+        let ns = norm(&style);
+        if ns.is_empty() || taken.contains(&ns) {
+            continue;
+        }
+        // The default instance is the face itself.
+        if coords.iter().zip(&defaults).all(|(c, d)| (c - d).abs() < 1e-3) {
+            keys.styles.push(ns.clone());
+            keys.postscript.push(norm(&format!("{prefix}{style}")));
+            taken.push(ns);
+            continue;
+        }
+        taken.push(ns);
+        let axis = |tag: &[u8; 4]| tags.iter().zip(&coords).find(|(t, _)| t.to_be_bytes() == *tag).map(|(_, v)| *v);
+        let weight = axis(b"wght").map(|w| w.clamp(1.0, 1000.0));
+        let italic = style_italic(&style) || axis(b"ital").is_some_and(|v| v >= 0.5) || axis(b"slnt").is_some_and(|v| v != 0.0);
+        let mut styles: Vec<String> = std::iter::once(style.clone()).chain(all_names(f, inst.subfamily_name_id())).map(|s| norm(&s)).collect();
+        let mut postscript: Vec<String> = inst.postscript_name_id().map(|id| all_names(f, id)).unwrap_or_default().iter().map(|n| norm(n)).collect();
+        postscript.push(norm(&format!("{prefix}{style}")));
+        for v in [&mut styles, &mut postscript] {
+            v.retain(|k| !k.is_empty());
+            v.sort();
+            v.dedup();
+        }
+        let keys = FaceKeys { families: keys.families.clone(), styles, legacy: vec![], postscript };
+        let variations = tags.iter().zip(&coords).map(|(t, v)| (t.to_be_bytes(), *v)).collect();
+        out.push(FaceStyle { family: family.to_string(), style, keys, variations, weight, italic });
+    }
+    out
+}
+
+/// Parse every face in `data` (a font file or collection) and the named instances of its variable
+/// ones. Returns each style with the index of its face.
+fn enumerate_faces(data: &[u8]) -> Vec<(u32, FaceStyle)> {
     let count = match FileRef::new(data) {
         Ok(FileRef::Font(_)) => 1,
         Ok(FileRef::Collection(c)) => c.len(),
         Err(_) => 0,
     };
     (0..count)
-        .filter_map(|i| {
-            let (family, style) = face_names(&skrifa::FontRef::from_index(data, i).ok()?)?;
-            Some((i, family, style))
-        })
+        .filter_map(|i| Some((i, skrifa::FontRef::from_index(data, i).ok()?)))
+        .flat_map(|(i, f)| face_styles(&f).into_iter().map(move |s| (i, s)))
         .collect()
 }
 
-/// (family, style) of every face in the font file at `path`, reading only its table directories
-/// and `name` tables: a scan opens hundreds of font files, many of them megabytes long.
+/// The styles of every face in the font file at `path` ([`face_styles`]), reading only its table
+/// directories and `name` and `fvar` tables: a scan opens hundreds of font files, many of them
+/// megabytes long.
 #[cfg(not(target_arch = "wasm32"))]
-fn file_face_names(path: &Path) -> Vec<(String, String)> {
+fn file_face_names(path: &Path) -> Vec<FaceStyle> {
     use std::io::{Read, Seek, SeekFrom};
     /// Caps on what a (possibly damaged) file can make the scan read.
     const MAX_FACES: u32 = 256;
@@ -269,26 +503,55 @@ fn file_face_names(path: &Path) -> Vec<(String, String)> {
             let dir = read_at(start.into(), 12)?;
             let tables = u16::from_be_bytes(dir.get(4..6)?.try_into().ok()?) as usize;
             let records = read_at(u64::from(start) + 12, tables * 16)?;
-            let rec: &[u8] = records.as_chunks::<16>().0.iter().find(|r| r.starts_with(b"name"))?;
-            let (offset, len) = (be32(rec, 8)?, be32(rec, 12)?);
-            if len > MAX_NAME_TABLE {
-                return None;
+            let mut table = |tag: &[u8; 4]| -> Option<Vec<u8>> {
+                let rec: &[u8] = records.as_chunks::<16>().0.iter().find(|r| r.starts_with(tag))?;
+                let (offset, len) = (be32(rec, 8)?, be32(rec, 12)?);
+                if len > MAX_NAME_TABLE {
+                    return None;
+                }
+                read_at(offset.into(), len as usize)
+            };
+            let name = table(b"name")?;
+            // A variable font's named instances are styles too.
+            let fvar = table(b"fvar");
+            // A font holding just these tables, to read them as the font itself would.
+            let mut tables: Vec<(&[u8; 4], &[u8])> = vec![(b"name", &name)];
+            if let Some(fvar) = &fvar {
+                tables.push((b"fvar", fvar));
             }
-            let table = read_at(offset.into(), len as usize)?;
-            // A one-table font holding just the `name` table, to read it as the font itself would.
-            let mut font = Vec::with_capacity(28 + table.len());
-            font.extend_from_slice(&0x0001_0000_u32.to_be_bytes());
-            font.extend_from_slice(&[0, 1, 0, 16, 0, 0, 0, 0]);
-            font.extend_from_slice(b"name");
-            for v in [0, 28, len] {
-                font.extend_from_slice(&u32::to_be_bytes(v));
-            }
-            font.extend_from_slice(&table);
-            face_names(&skrifa::FontRef::new(&font).ok()?)
+            let font = sfnt_of(&tables)?;
+            Some(face_styles(&skrifa::FontRef::new(&font).ok()?))
         })
+        .flatten()
         .collect()
 }
 
+/// A font file holding `tables` (tag, data), sorted by tag as table directories are.
+#[cfg(any(test, not(target_arch = "wasm32")))]
+pub(crate) fn sfnt_of(tables: &[(&[u8; 4], &[u8])]) -> Option<Vec<u8>> {
+    let mut tables = tables.to_vec();
+    tables.sort_by_key(|t| *t.0);
+    let n = u16::try_from(tables.len()).ok()?;
+    let mut font = Vec::new();
+    font.extend_from_slice(&0x0001_0000_u32.to_be_bytes());
+    for v in [n, 0, 0, 0] {
+        font.extend_from_slice(&v.to_be_bytes());
+    }
+    let mut offset = 12 + 16 * tables.len();
+    for (tag, data) in &tables {
+        font.extend_from_slice(*tag);
+        for v in [0, u32::try_from(offset).ok()?, u32::try_from(data.len()).ok()?] {
+            font.extend_from_slice(&v.to_be_bytes());
+        }
+        offset += data.len().next_multiple_of(4);
+    }
+    for (_, data) in &tables {
+        font.extend_from_slice(data);
+        font.resize(font.len().next_multiple_of(4), 0);
+    }
+    Some(font)
+}
+
 /// The platform's font folders (the system's and the user's), scanned by [`FontDb::global`].
 pub fn system_font_dirs() -> Vec<PathBuf> {
     let mut dirs: Vec<PathBuf> = Vec::new();
@@ -301,6 +564,13 @@ pub fn system_font_dirs() -> Vec<PathBuf> {
         if let Some(h) = &home {
             dirs.push(h.join("Library/Fonts"));
         }
+        // Fonts macOS downloads on demand (Yu Gothic, Yu Mincho, Tsukushi Maru Gothic…): one
+        // asset folder per font, under a catalog folder whose number changes with macOS.
+        for e in std::fs::read_dir("/System/Library/AssetsV2").into_iter().flatten().flatten() {
+            if e.file_name().to_string_lossy().starts_with("com_apple_MobileAsset_Font") {
+                dirs.push(e.path());
+            }
+        }
     } else if cfg!(windows) {
         let root = std::env::var_os("WINDIR").map(PathBuf::from).unwrap_or_else(|| "C:\\Windows".into());
         dirs.push(root.join("Fonts"));
@@ -317,21 +587,31 @@ pub fn system_font_dirs() -> Vec<PathBuf> {
     dirs
 }
 
-fn make_face(bytes: FontBytes, index: u32, family: String, style: String, path: Option<std::path::PathBuf>) -> Option<FontFace> {
+fn make_face(bytes: FontBytes, index: u32, spec: FaceStyle, path: Option<std::path::PathBuf>) -> Option<FontFace> {
     let data: &[u8] = match &bytes {
         FontBytes::Static(b) => b,
         FontBytes::Owned(v) => v.as_slice(),
     };
     let f = skrifa::FontRef::from_index(data, index).ok()?;
-    let m = f.metrics(Size::unscaled(), LocationRef::default());
+    let FaceStyle { family, style, keys, variations, weight, italic } = spec;
+    // A named instance: outlines, metrics and advances at its axis settings.
+    let location = if variations.is_empty() { Location::default() } else { f.axes().location(variations.iter().map(|(t, v)| (Tag::new(t), *v))) };
+    let m = f.metrics(Size::unscaled(), &location);
     let a = f.attributes();
-    let shaper = harfrust::ShaperData::new(&harfrust::FontRef::from_index(data, index).ok()?);
+    let hb = harfrust::FontRef::from_index(data, index).ok()?;
+    let shaper = harfrust::ShaperData::new(&hb);
+    let instance =
+        (!variations.is_empty()).then(|| harfrust::ShaperInstance::from_variations(&hb, variations.iter().map(|(t, v)| (harfrust::Tag::new(t), *v))));
     Some(FontFace {
+        keys,
         id: NEXT_ID.fetch_add(1, Ordering::Relaxed),
         family,
         style,
-        weight: a.weight.value(),
-        italic: !matches!(a.style, skrifa::attribute::Style::Normal),
+        weight: weight.unwrap_or(a.weight.value()),
+        italic: italic || !matches!(a.style, skrifa::attribute::Style::Normal),
+        variations,
+        location,
+        instance,
         upem: m.units_per_em.max(1) as f64,
         ascent: m.ascent as f64,
         descent: -(m.descent as f64),
@@ -379,13 +659,19 @@ fn style_italic(style: &str) -> bool {
     s.contains("italic") || s.contains("oblique") || s == "it"
 }
 
+/// [`FontDb::menu_family_list`], with the [`FontDb::family_list`] it was built from.
+type MenuFamilies = (Arc<[String]>, Arc<[String]>);
+
 impl FontDb {
     /// A database holding the bundled fonts, whose system font scan reads `font_dirs`.
     pub fn with_font_dirs(font_dirs: Vec<PathBuf>) -> Self {
         let mut faces = Vec::new();
-        for data in BUNDLED {
-            for (i, family, style) in enumerate_faces(data) {
-                if let Some(f) = make_face(FontBytes::Static(data), i, family, style, None) {
+        // The bundled fonts, then the Japanese craft-fonts faces (when built with them), Mincho
+        // first: fallbacks for Japanese text after the requested and bundled fonts.
+        let craft = crate::craft_fonts::japanese_document_fonts().into_iter().map(|f| f.bytes);
+        for data in BUNDLED.iter().copied().chain(craft) {
+            for (i, spec) in enumerate_faces(data) {
+                if let Some(f) = make_face(FontBytes::Static(data), i, spec, None) {
                     faces.push(Arc::new(f));
                 }
             }
@@ -394,10 +680,13 @@ impl FontDb {
             faces: RwLock::new(faces),
             outlines: Mutex::new(HashMap::new()),
             catalog: RwLock::new(Catalog::new()),
+            postscript: RwLock::new(PostScriptNames::new()),
             font_dirs,
+            aliases: RwLock::new(HashMap::new()),
             #[cfg(not(target_arch = "wasm32"))]
             cataloged: std::sync::OnceLock::new(),
             family_cache: Mutex::new(None),
+            menu_cache: Mutex::new(None),
             generation: AtomicU64::new(0),
             #[cfg(not(target_arch = "wasm32"))]
             sys: Mutex::new(SysFallback { enabled: true, ..Default::default() }),
@@ -465,14 +754,33 @@ impl FontDb {
         list
     }
 
+    /// The families font menus and lists show: [`FontDb::family_list`] without the system's hidden
+    /// families, whose names start with "." (macOS keeps ".SF NS", ".LastResort" and others for its
+    /// own interface, and Mac apps don't list them). Those still resolve by name, for documents and
+    /// fallbacks that name them. Cheap to call every frame.
+    pub fn menu_family_list(&self) -> Arc<[String]> {
+        let all = self.family_list();
+        let mut cache = self.menu_cache.lock().unwrap_or_else(|e| e.into_inner());
+        if let Some((from, list)) = cache.as_ref()
+            && Arc::ptr_eq(from, &all)
+        {
+            return list.clone();
+        }
+        let list: Arc<[String]> = all.iter().filter(|f| !f.starts_with('.')).cloned().collect();
+        *cache = Some((all, list.clone()));
+        list
+    }
+
     /// Style names available for `family`: upright styles by weight, then italics.
     pub fn styles(&self, family: &str) -> Vec<String> {
+        let (family, _) = self.canonical(family, "");
+        let family = family.as_str();
         let mut v: Vec<(bool, f32, String)> =
             self.read_faces().iter().filter(|f| f.family.eq_ignore_ascii_case(family)).map(|f| (f.italic, f.weight, f.style.clone())).collect();
         if let Some(c) = self.read_catalog().get(&family.to_ascii_lowercase()) {
-            for (style, _) in &c.faces {
-                if !v.iter().any(|(_, _, s)| s.eq_ignore_ascii_case(style)) {
-                    v.push((style_italic(style), style_weight(style), style.clone()));
+            for cf in &c.faces {
+                if !v.iter().any(|(_, _, s)| s.eq_ignore_ascii_case(&cf.style)) {
+                    v.push((cf.italic, cf.weight, cf.style.clone()));
                 }
             }
         }
@@ -491,11 +799,11 @@ impl FontDb {
     fn add_font_from(&self, bytes: Vec<u8>, path: Option<&Path>) -> usize {
         let data = Arc::new(bytes);
         let mut added = 0;
-        for (i, family, style) in enumerate_faces(&data) {
-            if self.read_faces().iter().any(|f| f.family.eq_ignore_ascii_case(&family) && f.style.eq_ignore_ascii_case(&style)) {
+        for (i, spec) in enumerate_faces(&data) {
+            if self.read_faces().iter().any(|f| f.family.eq_ignore_ascii_case(&spec.family) && f.style.eq_ignore_ascii_case(&spec.style)) {
                 continue;
             }
-            if let Some(f) = make_face(FontBytes::Owned(data.clone()), i, family, style, path.map(Path::to_path_buf)) {
+            if let Some(f) = make_face(FontBytes::Owned(data.clone()), i, spec, path.map(Path::to_path_buf)) {
                 self.faces.write().unwrap_or_else(|e| e.into_inner()).push(Arc::new(f));
                 added += 1;
             }
@@ -540,6 +848,8 @@ impl FontDb {
     #[cfg(not(target_arch = "wasm32"))]
     fn scan_font_dirs(&self) -> usize {
         let mut catalog = Catalog::new();
+        let mut aliases: HashMap<String, Vec<Alias>> = HashMap::new();
+        let mut postscript = PostScriptNames::new();
         let mut n = 0;
         let mut stack = self.font_dirs.clone();
         // Each folder once, however links lead back to it.
@@ -559,27 +869,110 @@ impl FontDb {
                 if !matches!(ext.as_deref(), Some("ttf" | "otf" | "ttc" | "otc")) {
                     continue;
                 }
-                for (family, style) in file_face_names(&p) {
+                for FaceStyle { family, style, keys, weight, italic, .. } in file_face_names(&p) {
+                    for (k, a) in Alias::of(&family, &style, &keys) {
+                        aliases.entry(k).or_default().push(a);
+                    }
+                    // `keys.postscript` is normalized ([`norm`]), as `by_postscript_name` looks it up.
+                    for ps in &keys.postscript {
+                        postscript.insert(ps.clone(), (family.clone(), style.clone()));
+                    }
                     let entry = catalog.entry(family.to_ascii_lowercase()).or_default();
                     if entry.name.is_empty() {
                         entry.name = family;
                     }
-                    entry.faces.push((style, p.clone()));
+                    let (weight, italic) = (weight.unwrap_or_else(|| style_weight(&style)), italic || style_italic(&style));
+                    entry.faces.push(CatalogFace { style, path: p.clone(), weight, italic });
                     n += 1;
                 }
             }
         }
         log::debug!("cataloged {n} system font faces");
         *self.catalog.write().unwrap_or_else(|e| e.into_inner()) = catalog;
+        *self.aliases.write().unwrap_or_else(|e| e.into_inner()) = aliases;
+        *self.postscript.write().unwrap_or_else(|e| e.into_inner()) = postscript;
         self.changed();
         n
     }
 
+    /// The family's own name and the style for a name given in a document: any of a family's
+    /// names (`ヒラギノ角ゴシック` is Hiragino Sans), a legacy family name (`Hiragino Sans W6` with its
+    /// legacy style names the W6 face) or a PostScript name (`HiraginoSans-W6`, as PDF and `.ai`
+    /// files name fonts). Case and anything but letters and digits are ignored. A name nothing
+    /// answers to comes back as it is.
+    pub fn canonical(&self, family: &str, style: &str) -> (String, String) {
+        if self.is_loaded(family) || self.read_catalog().contains_key(&family.to_ascii_lowercase()) {
+            return (family.to_string(), style.to_string());
+        }
+        let key = norm(family);
+        let mut found: Vec<Alias> =
+            self.read_faces().iter().flat_map(|f| Alias::of(&f.family, &f.style, &f.keys)).filter(|(k, _)| *k == key).map(|(_, a)| a).collect();
+        if let Some(v) = self.aliases.read().unwrap_or_else(|e| e.into_inner()).get(&key) {
+            found.extend(v.iter().cloned());
+        }
+        let ns = norm(style);
+        // A family name keeps the style asked for; a legacy pair names its face; a PostScript name
+        // its face whatever style is asked for.
+        if let Some(a) = found.iter().find(|a| a.style.is_none()) {
+            return (a.family.clone(), style.to_string());
+        }
+        if let Some(a) = found.iter().find(|a| a.paired.as_ref().is_some_and(|p| *p == ns) || a.paired.is_none()) {
+            return (a.family.clone(), a.style.clone().unwrap_or_else(|| style.to_string()));
+        }
+        match found.first() {
+            Some(a) => (a.family.clone(), style.to_string()),
+            None => (family.to_string(), style.to_string()),
+        }
+    }
+
+    /// [`face`](Self::face) by any of the family's names ([`canonical`](Self::canonical)), and how
+    /// it matched.
+    pub fn resolve(&self, family: &str, style: &str) -> Option<(Arc<FontFace>, FontMatch)> {
+        let (family, style) = self.canonical(family, style);
+        let f = self.face(&family, &style)?;
+        let m = if !f.family.eq_ignore_ascii_case(&family) {
+            FontMatch::Missing
+        } else if norm(&f.style) == norm(&style) || f.keys.styles.contains(&norm(&style)) {
+            FontMatch::Exact
+        } else {
+            FontMatch::Style
+        };
+        Some((f, m))
+    }
+
+    /// The installed face whose PostScript name is `name` (`HiraginoSans-W3`; any case), loaded
+    /// from the system fonts if need be. `None` when no installed font has the name.
+    pub fn find_postscript(&self, name: &str) -> Option<Arc<FontFace>> {
+        let key = norm(name);
+        if key.is_empty() {
+            return None;
+        }
+        let loaded = |db: &FontDb| db.read_faces().iter().find(|f| f.keys.postscript.contains(&key)).cloned();
+        if let Some(f) = loaded(self) {
+            return Some(f);
+        }
+        self.ensure_catalog();
+        let face = self.aliases.read().unwrap_or_else(|e| e.into_inner()).get(&key).and_then(|v| {
+            v.iter().find(|a| a.paired.is_none() && a.style.is_some()).map(|a| (a.family.clone(), a.style.clone().unwrap_or_default()))
+        });
+        let (family, style) = face?;
+        self.face(&family, &style)?;
+        loaded(self)
+    }
+
+    /// The (family, style) of the installed face whose PostScript name is `name` (ignoring ASCII
+    /// case). Documents name fonts this way, and a family can hold hyphens
+    /// ("Rounded-X-Mplus-1c-black" is Rounded-X M+ 1c, black), so the name can't be split.
+    pub fn by_postscript_name(&self, name: &str) -> Option<(String, String)> {
+        self.ensure_catalog();
+        self.postscript.read().unwrap_or_else(|e| e.into_inner()).get(&norm(name)).cloned()
+    }
+
     /// Load the files of the installed `family`. Returns whether any face was added.
     #[cfg(not(target_arch = "wasm32"))]
     fn load_cataloged(&self, family: &str) -> bool {
         let mut paths: Vec<PathBuf> =
-            self.read_catalog().get(&family.to_ascii_lowercase()).map(|c| c.faces.iter().map(|(_, p)| p.clone()).collect()).unwrap_or_default();
+            self.read_catalog().get(&family.to_ascii_lowercase()).map(|c| c.faces.iter().map(|cf| cf.path.clone()).collect()).unwrap_or_default();
         paths.sort();
         paths.dedup();
         let mut any = false;
@@ -596,17 +989,21 @@ impl FontDb {
     /// only if no font at all is loaded (the bundled fonts failed to parse), in which case text has
     /// no glyphs.
     pub fn face(&self, family: &str, style: &str) -> Option<Arc<FontFace>> {
+        let (family, style) = self.canonical(family, style);
+        let (family, style) = (family.as_str(), style.as_str());
         let found = self.find(family, style);
         if found.as_ref().is_some_and(|f| norm(&f.style) == norm(style)) {
             return found;
         }
-        // The family, or this style of it, is installed but not loaded yet.
+        // The family, or this style of it, is installed but not loaded yet. Looked for again
+        // whether or not this call loaded it: another thread may have just done so (then this
+        // load adds nothing, but the face is there).
         #[cfg(not(target_arch = "wasm32"))]
-        if (found.is_none() || self.is_cataloged(family, style))
-            && self.load_cataloged(family)
-            && let Some(f) = self.find(family, style)
-        {
-            return Some(f);
+        if found.is_none() || self.is_cataloged(family, style) {
+            self.load_cataloged(family);
+            if let Some(f) = self.find(family, style) {
+                return Some(f);
+            }
         }
         found
             .or_else(|| self.find(FALLBACK_FAMILY, style))
@@ -618,7 +1015,7 @@ impl FontDb {
     #[cfg(not(target_arch = "wasm32"))]
     fn is_cataloged(&self, family: &str, style: &str) -> bool {
         let ns = norm(style);
-        self.read_catalog().get(&family.to_ascii_lowercase()).is_some_and(|c| c.faces.iter().any(|(s, _)| norm(s) == ns))
+        self.read_catalog().get(&family.to_ascii_lowercase()).is_some_and(|c| c.faces.iter().any(|cf| norm(&cf.style) == ns))
     }
 
     /// The loaded face with [`FontFace::id`] `id` (the face a laid-out glyph came from).
@@ -634,7 +1031,8 @@ impl FontDb {
 
     /// Is `family` available (loaded, or installed on the system)?
     pub fn has_family(&self, family: &str) -> bool {
-        self.is_loaded(family) || self.read_catalog().contains_key(&family.to_ascii_lowercase())
+        let (family, _) = self.canonical(family, "");
+        self.is_loaded(&family) || self.read_catalog().contains_key(&family.to_ascii_lowercase())
     }
 
     pub(crate) fn is_loaded(&self, family: &str) -> bool {
@@ -651,6 +1049,11 @@ impl FontDb {
         if let Some(f) = cands.iter().find(|f| norm(&f.style) == ns) {
             return Some((*f).clone());
         }
+        // Another of a face's style names: in another language, or a variable font's default
+        // instance's name.
+        if let Some(f) = cands.iter().find(|f| f.keys.styles.contains(&ns)) {
+            return Some((*f).clone());
+        }
         let (tw, ti) = (style_weight(style), style_italic(style));
         cands
             .iter()
@@ -708,7 +1111,7 @@ impl FontDb {
                 return true;
             }
         }
-        let mut paths: Vec<PathBuf> = self.read_catalog().values().flat_map(|c| c.faces.iter().map(|(_, p)| p.clone())).collect();
+        let mut paths: Vec<PathBuf> = self.read_catalog().values().flat_map(|c| c.faces.iter().map(|cf| cf.path.clone())).collect();
         paths.sort();
         paths.dedup();
         for p in paths {
@@ -716,8 +1119,7 @@ impl FontDb {
                 continue;
             }
             let Ok(data) = std::fs::read(&p) else { continue };
-            let hit =
-                enumerate_faces(&data).iter().any(|(i, _, _)| skrifa::FontRef::from_index(&data, *i).is_ok_and(|f| f.charmap().map(c).is_some()));
+            let hit = enumerate_faces(&data).iter().any(|(i, _)| skrifa::FontRef::from_index(&data, *i).is_ok_and(|f| f.charmap().map(c).is_some()));
             if hit && self.add_font_from(data, Some(&p)) > 0 && covered(self) {
                 return true;
             }
@@ -736,7 +1138,7 @@ impl FontDb {
         if let Some(f) = face.skrifa()
             && let Some(g) = f.outline_glyphs().get(GlyphId::new(gid))
         {
-            let _ = g.draw(DrawSettings::unhinted(Size::unscaled(), LocationRef::default()), &mut pen);
+            let _ = g.draw(DrawSettings::unhinted(Size::unscaled(), face.location()), &mut pen);
         }
         let p = Arc::new(pen.0);
         let mut cache = self.outlines.lock().unwrap_or_else(|e| e.into_inner());
@@ -767,3 +1169,114 @@ impl OutlinePen for FlipPen {
         self.0.close_path();
     }
 }
+
+#[cfg(test)]
+mod alias_tests {
+    use super::*;
+
+    /// A one-table font holding a name table from (platform, language, name id, string) records:
+    /// Windows Unicode (UTF-16) or Mac Roman (ASCII here).
+    fn name_font(records: &[(u16, u16, u16, &str)]) -> Vec<u8> {
+        let (mut head, mut strings) = (vec![], vec![]);
+        let n = records.len() as u16;
+        for v in [0, n, 6 + 12 * n] {
+            head.extend_from_slice(&v.to_be_bytes());
+        }
+        for &(platform, lang, id, s) in records {
+            let bytes: Vec<u8> = if platform == 3 { s.encode_utf16().flat_map(u16::to_be_bytes).collect() } else { s.as_bytes().to_vec() };
+            let encoding = if platform == 3 { 1 } else { 0 };
+            for v in [platform, encoding, lang, id, bytes.len() as u16, strings.len() as u16] {
+                head.extend_from_slice(&v.to_be_bytes());
+            }
+            strings.extend(bytes);
+        }
+        head.extend(strings);
+        let mut font = vec![0, 1, 0, 0, 0, 1, 0, 16, 0, 0, 0, 0];
+        font.extend_from_slice(b"name");
+        for v in [0u32, 28, head.len() as u32] {
+            font.extend_from_slice(&v.to_be_bytes());
+        }
+        font.extend(head);
+        font
+    }
+
+    fn keys(records: &[(u16, u16, u16, &str)]) -> (String, String, FaceKeys) {
+        let font = name_font(records);
+        let f = skrifa::FontRef::new(&font).unwrap();
+        let (family, style) = face_names(&f).unwrap();
+        let k = FaceKeys::of(&f, &family, &style);
+        (family, style, k)
+    }
+
+    const EN: u16 = 0x0409;
+    const JA: u16 = 0x0411;
+
+    /// Laid out like the name table of Hiragino Sans W3.
+    const HIRAGINO_W3: &[(u16, u16, u16, &str)] = &[
+        (1, 0, 1, "Hiragino Sans"),
+        (1, 0, 2, "W3"),
+        (3, EN, 1, "Hiragino Sans W3"),
+        (3, EN, 2, "Regular"),
+        (3, JA, 1, "ヒラギノ角ゴシック W3"),
+        (3, JA, 2, "Regular"),
+        (3, EN, 6, "HiraginoSans-W3"),
+        (3, EN, 16, "Hiragino Sans"),
+        (3, JA, 16, "ヒラギノ角ゴシック"),
+        (3, EN, 17, "W3"),
+        (3, JA, 17, "W3"),
+    ];
+
+    #[test]
+    fn a_face_answers_to_its_names_in_every_language() {
+        let (family, style, k) = keys(HIRAGINO_W3);
+        assert_eq!((family.as_str(), style.as_str()), ("Hiragino Sans", "W3"));
+        let aliases = Alias::of(&family, &style, &k);
+        let find = |name: &str| aliases.iter().filter(|(n, _)| *n == norm(name)).map(|(_, a)| a.clone()).collect::<Vec<_>>();
+        assert!(find("ヒラギノ 角ゴシック").iter().any(|a| a.family == "Hiragino Sans" && a.style.is_none()), "a family name in Japanese");
+        let legacy = find("Hiragino Sans W3");
+        assert!(legacy.iter().any(|a| a.style.as_deref() == Some("W3") && a.paired.as_deref() == Some("regular")), "{legacy:?}");
+        assert!(!legacy.iter().any(|a| a.paired.as_deref() == Some("w3")), "Mac family + Windows style is no pair");
+        assert!(find("HiraginoSans-W3").iter().any(|a| a.style.as_deref() == Some("W3") && a.paired.is_none()), "the PostScript name");
+    }
+
+    #[test]
+    fn without_typographic_names_the_legacy_ones_are_the_familys() {
+        let (family, style, k) = keys(&[(3, EN, 1, "Example Serif"), (3, EN, 2, "Bold Italic"), (3, JA, 1, "例セリフ"), (3, JA, 2, "太字斜体")]);
+        assert_eq!((family.as_str(), style.as_str()), ("Example Serif", "Bold Italic"));
+        assert!(k.families.contains(&norm("例セリフ")) && k.styles.contains(&norm("太字斜体")) && k.legacy.is_empty());
+    }
+
+    #[test]
+    fn resolve_says_how_a_font_matched() {
+        let db = FontDb::with_font_dirs(vec![]);
+        let m = |f: &str, s: &str| db.resolve(f, s).map(|(face, m)| (face.family.clone(), face.style.clone(), m)).unwrap();
+        assert_eq!(m("Source Sans 3", "Semibold"), ("Source Sans 3".into(), "Semibold".into(), FontMatch::Exact));
+        assert_eq!(m("Source Sans 3", "Black").2, FontMatch::Style);
+        assert_eq!(m("No Such Family", "Regular"), (FALLBACK_FAMILY.into(), "Regular".into(), FontMatch::Missing));
+        // A PostScript name names its face, whatever style is asked for (text opened from a PDF).
+        assert_eq!(m("SourceSans3-Semibold", "Regular"), ("Source Sans 3".into(), "Semibold".into(), FontMatch::Exact));
+        let semi = db.find_postscript("sourcesans3-semibold").unwrap();
+        assert_eq!(semi.style, "Semibold");
+        assert!(db.find_postscript("NoSuchFont-Regular").is_none());
+        assert!(db.has_family("SourceSans3-Regular"));
+    }
+}
+
+#[cfg(test)]
+mod race_tests {
+    use super::*;
+
+    #[test]
+    fn a_family_loaded_by_another_thread_meanwhile_is_still_found() {
+        // Two threads ask for the same installed family at once: each must get it, not the
+        // fallback (the second one's load finds every face already added).
+        let dir = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../../assets/fonts");
+        let db: &'static FontDb = Box::leak(Box::new(FontDb::with_font_dirs(vec![dir])));
+        // Only the catalog knows Inter (the bundled faces are dropped).
+        db.faces.write().unwrap().retain(|f| f.family != "Inter");
+        let threads: Vec<_> = (0..8).map(|_| std::thread::spawn(move || db.face("Inter", "Regular").map(|f| f.family.clone()))).collect();
+        for t in threads {
+            assert_eq!(t.join().unwrap().as_deref(), Some("Inter"));
+        }
+    }
+}

crates/text/src/layout.rs

@@ -8,17 +8,22 @@ use vectorcraft_doc::{CharStyle, Justify, ParaStyle, PathEffect, TextKind, TextO
 use crate::composer::{Breakpoint, compose};
 use crate::fontdb::FontDb;
 use crate::hyphen::hyphen_points;
-use crate::shape::{SGlyph, cap_x_heights, hyphen_glyph, shape_range, style_metrics};
-use crate::{Composer, FirstBaseline, LayoutOptions, LineInfo, PositionedGlyph, TextLayout};
+use crate::shape::{SGlyph, Tcy, cap_x_heights, hyphen_glyph, no_line_end, no_line_start, shape_range, style_metrics};
+use crate::{Composer, FirstBaseline, LayoutOptions, LineInfo, OtFeatures, PositionedGlyph, TextLayout};
 
 const EPS: f64 = 1e-6;
 
 struct Ctx<'a> {
+    on_path: bool,
     db: &'a FontDb,
     text: &'a str,
     runs: Vec<(Range<usize>, &'a CharStyle)>,
     default: CharStyle,
     opts: &'a LayoutOptions,
+    /// Vertical type: lines are laid out as horizontal lines in line space, upright glyphs turned
+    /// a quarter turn back (see [`stands_upright`]); [`TextLayout::line_xf`] then stands the lines
+    /// up as columns.
+    vertical: bool,
     out: TextLayout,
 }
 
@@ -31,13 +36,42 @@ impl Ctx<'_> {
     fn shape_para(&self, r: Range<usize>) -> Vec<SGlyph> {
         let mut v = Vec::with_capacity(r.len());
         shape_range(self.db, self.text, r, &self.runs, &self.opts.features, &mut v);
+        if self.vertical {
+            tate_chu_yoko(&mut v, |g| self.style_at(g.byte).size);
+            // An upright glyph advances at least one em down the column (the vertical advance of
+            // CJK fonts), centred in it: a narrow mark like § must not overlap its neighbours.
+            for g in v.iter_mut().filter(|g| g.adv > 0.0 && stands_upright(g)) {
+                let extra = upright_cell(g) - g.face.advance(g.gid) * g.sx;
+                g.dx += extra * 0.5;
+                g.adv += extra;
+            }
+        }
         v
     }
 
     fn emit(&mut self, g: &SGlyph, pre: Affine, origin: Point, angle: f64, advance: f64, line: usize) {
         let src = self.db.outline(&g.face, g.gid);
         let local = Affine::rotate(-g.rotation.to_radians()) * Affine::translate((g.dx, g.dy - g.bshift)) * Affine::scale_non_uniform(g.sx, g.sy);
-        let m = pre * local;
+        let mut m = pre * local;
+        if self.vertical && self.on_path {
+            // Vertical path type keeps the baseline path and turns each glyph across it.
+            m = Affine::rotate_about(std::f64::consts::FRAC_PI_2, origin) * m;
+        } else if let (true, Some(t)) = (self.vertical, g.tcy) {
+            // Tate-chu-yoko: the block set across the column, centred on its em of it.
+            let em = self.style_at(g.byte).size;
+            let start = origin.x - t.pen;
+            let centre = Point::new(start + em * 0.5, origin.y - EM_CENTER * em);
+            let across = Affine::translate((centre.x - t.width * 0.5 + t.ink - origin.x, 0.0));
+            let squeeze = Affine::translate((centre.x, 0.0)) * Affine::scale_non_uniform(t.squeeze, 1.0) * Affine::translate((-centre.x, 0.0));
+            m = Affine::rotate_about(-std::f64::consts::FRAC_PI_2, centre) * squeeze * across * m;
+        } else if self.vertical && stands_upright(g) {
+            // Turned about the centre of its em box, which the column's centre line runs through:
+            // the middle of its own cell, not of its advance (tracking and justification add space
+            // after the cell, and must not push the glyph off the centre line).
+            let em = self.style_at(g.byte).size;
+            let cell = if g.adv > 0.0 { upright_cell(g) } else { advance };
+            m = Affine::rotate_about(-std::f64::consts::FRAC_PI_2, Point::new(origin.x + cell * 0.5, origin.y - EM_CENTER * em)) * m;
+        }
         // Control characters (tabs) and soft hyphens draw nothing (fonts map them to .notdef).
         let outline = if src.elements().is_empty() || g.is_soft_hyphen() || g.ch.is_control() {
             BezPath::new()
@@ -99,21 +133,128 @@ pub fn layout_with(db: &FontDb, t: &TextObject, opts: &LayoutOptions) -> TextLay
         }
     }
     paras.push(s..text.len());
-    let mut cx = Ctx { db, text: &text, runs, default: CharStyle::default(), opts, out: TextLayout::default() };
+    let vertical = t.vertical;
+    let is_on_path = matches!(&t.kind, TextKind::OnPath { .. });
+    let vopts;
+    let opts = if vertical {
+        vopts = LayoutOptions { features: OtFeatures { vertical: true, ..opts.features }, ..opts.clone() };
+        &vopts
+    } else {
+        opts
+    };
+    let mut cx = Ctx { on_path: is_on_path, db, text: &text, runs, default: CharStyle::default(), opts, vertical, out: TextLayout::default() };
+    // Vertical type: line space turned a quarter turn clockwise (lines become columns, each next
+    // one to the left). Point type's anchor is on the first column's centre line. Vertical path
+    // type stays on its path (each glyph turned across it in `emit`).
+    let line_xf = match &t.kind {
+        _ if !vertical => Affine::IDENTITY,
+        TextKind::OnPath { .. } => Affine::IDENTITY,
+        TextKind::Point => Affine::translate((-EM_CENTER * cx.style_at(0).size, 0.0)) * QUARTER_TURN,
+        _ => QUARTER_TURN,
+    };
     match &t.kind {
         TextKind::Point => flow(&mut cx, &paras, &t.para, None),
         TextKind::Area { frame } => {
-            let regions = Region::cells(&frame.to_bezpath(), opts, &t.wrap);
-            cx.out.frames = regions.iter().map(|r| r.cell).collect();
+            let to_lines = line_xf.inverse();
+            let wrap: Vec<vectorcraft_doc::WrapShape> = if vertical {
+                t.wrap.iter().map(|w| vectorcraft_doc::WrapShape { path: w.path.transformed(to_lines), ..w.clone() }).collect()
+            } else {
+                t.wrap.clone()
+            };
+            let regions = Region::cells(&(to_lines * frame.to_bezpath()), opts, &wrap);
+            cx.out.frames = regions.iter().map(|r| line_xf.transform_rect_bbox(r.cell)).collect();
             flow(&mut cx, &paras, &t.para, Some(&regions));
         }
         TextKind::OnPath { path, start } => on_path(&mut cx, &paras, &t.para, &path.to_bezpath(), *start, path.is_closed(), t.path_effect),
     }
+    if vertical && !is_on_path {
+        // Glyph origins, outlines and transforms to text space (lines stay in line space).
+        for g in &mut cx.out.glyphs {
+            g.outline.apply_affine(line_xf);
+            g.xf = line_xf * g.xf;
+            g.origin = line_xf * g.origin;
+            g.angle += std::f64::consts::FRAC_PI_2;
+        }
+        cx.out.vertical = true;
+        cx.out.line_xf = line_xf;
+    }
     finish_bounds(&mut cx.out);
     cx.out
 }
 
+/// Tate-chu-yoko: a run of two or three half-width digits (`10`月, `100`年) stands upright across
+/// the column as one block one em long, squeezed to the em when wider; longer numbers (`2026`)
+/// stay on their side.
+fn tate_chu_yoko(g: &mut [SGlyph], size: impl Fn(&SGlyph) -> f64) {
+    let digits: Vec<bool> = g.iter().map(|g| g.ch.is_ascii_digit()).collect();
+    let digit = |i: usize| digits.get(i).copied().unwrap_or(false);
+    let mut i = 0;
+    while i < g.len() {
+        if !digit(i) {
+            i += 1;
+            continue;
+        }
+        let mut end = i;
+        while digit(end) {
+            end += 1;
+        }
+        if (2..=3).contains(&(end - i)) {
+            let em = size(&g[i]);
+            let width: f64 = g[i..end].iter().map(|g| g.adv).sum();
+            let squeeze = if width > em && width > 0.0 { em / width } else { 1.0 };
+            let mut ink = 0.0;
+            for (k, gl) in g[i..end].iter_mut().enumerate() {
+                let adv = gl.adv;
+                gl.tcy = Some(Tcy { pen: if k == 0 { 0.0 } else { em }, ink, width, squeeze });
+                gl.adv = if k == 0 { em } else { 0.0 };
+                ink += adv;
+            }
+        }
+        i = end;
+    }
+}
+
+/// The length an upright glyph takes down the column before tracking and justification: its
+/// advance, at least one em.
+fn upright_cell(g: &SGlyph) -> f64 {
+    (g.face.advance(g.gid) * g.sx).max(g.face.units_per_em() * g.sx)
+}
+
+/// Height of the centre of the ideographic em box above the baseline, in ems (the em box runs
+/// from 0.12 em below the baseline to 0.88 em above it).
+const EM_CENTER: f64 = 0.38;
+
+/// A quarter turn clockwise (y down), exact: line space → text space for vertical type.
+const QUARTER_TURN: Affine = Affine::new([0.0, 1.0, -1.0, 0.0, 0.0, 0.0]);
+
+/// Does the glyph stand upright in vertical type? CJK characters and symbols do (their vertical
+/// forms come from the font's `vert` feature); Latin letters, digits and other characters lie on
+/// their side. Brackets, the long vowel mark and similar marks that need a vertical form lie on
+/// their side when the font has none (Unicode's Vertical_Orientation Tr).
+fn stands_upright(g: &SGlyph) -> bool {
+    let c = g.ch as u32;
+    let upright = matches!(c,
+        0x00A7 | 0x00A9 | 0x00AE | 0x00B1 | 0x00BC..=0x00BE | 0x00D7 | 0x00F7
+        | 0x2016 | 0x2020 | 0x2021 | 0x2030 | 0x2031 | 0x203B | 0x203C | 0x2042 | 0x2047..=0x2049 | 0x2051
+        | 0x20DD..=0x20E0 | 0x20E2..=0x20E4 | 0x2100..=0x2101 | 0x2103..=0x2109 | 0x210F | 0x2113 | 0x2116 | 0x2117
+        | 0x211E..=0x2123 | 0x2125 | 0x2127 | 0x2129 | 0x212E | 0x2135..=0x213F | 0x2145..=0x214A | 0x214C | 0x214D | 0x214F..=0x2189
+        | 0x2460..=0x24FF | 0x25A0..=0x27BF | 0x2B12..=0x2B2F | 0x2B50..=0x2B59
+        | 0x1100..=0x11FF | 0x2E80..=0x303F | 0x3040..=0xA4CF | 0xA960..=0xA97F | 0xAC00..=0xD7FF
+        | 0xE000..=0xFAFF | 0xFE10..=0xFE1F | 0xFE30..=0xFE4F | 0xFE50..=0xFE6F | 0xFF00..=0xFFE7
+        | 0x1F000..=0x1FAFF | 0x20000..=0x3FFFF);
+    if !upright {
+        return false;
+    }
+    let needs_vertical_form = matches!(c,
+        0x3001 | 0x3002 | 0x3008..=0x3011 | 0x3013..=0x301F | 0x3030 | 0x30A0 | 0x30FC
+        | 0xFE50..=0xFE52 | 0xFE59..=0xFE5E | 0xFF01 | 0xFF08 | 0xFF09 | 0xFF0C | 0xFF0E | 0xFF1A | 0xFF1B | 0xFF1F
+        | 0xFF3B | 0xFF3D | 0xFF3F | 0xFF5B..=0xFF60 | 0xFFE3);
+    // Without a vertical alternate the shaped glyph is the nominal one.
+    !needs_vertical_form || g.gid != g.face.glyph_for(g.ch)
+}
+
 fn finish_bounds(out: &mut TextLayout) {
+    let xf = out.line_xf;
     let mut b: Option<Rect> = None;
     let mut add = |r: Rect| b = Some(b.map_or(r, |b| b.union(r)));
     for g in &out.glyphs {
@@ -123,7 +264,7 @@ fn finish_bounds(out: &mut TextLayout) {
     }
     if !out.on_path {
         for l in &out.lines {
-            add(Rect::new(l.x0.min(l.x1), l.baseline - l.ascent, l.x0.max(l.x1), l.baseline + l.descent));
+            add(xf.transform_rect_bbox(Rect::new(l.x0.min(l.x1), l.baseline - l.ascent, l.x0.max(l.x1), l.baseline + l.descent)));
         }
     }
     out.bounds = b.unwrap_or_default();
@@ -457,7 +598,7 @@ fn break_line(text: &str, g: &[SGlyph], i: usize, width: f64, hyphenate: bool) -
             break;
         }
         x += gl.adv;
-        if gl.break_after() {
+        if gl.break_after() && kinsoku_allows(g, j) {
             if gl.is_soft_hyphen() {
                 if x + hyphen_glyph(gl).adv <= width + EPS {
                     last_break = Some((j + 1, true));
@@ -479,7 +620,7 @@ fn break_line(text: &str, g: &[SGlyph], i: usize, width: f64, hyphenate: bool) -
             we += 1;
         }
         let x_ws: f64 = g[i..word_start].iter().map(|g| g.adv).sum();
-        let pts = hyphen_breaks(text, g, word_start, we);
+        let pts: Vec<usize> = hyphen_breaks(text, g, word_start, we).into_iter().filter(|&k| k > 0 && kinsoku_allows(g, k - 1)).collect();
         for &k in pts.iter().rev() {
             if k <= j && k > i {
                 let w = x_ws + g[word_start..k].iter().map(|g| g.adv).sum::<f64>() + hyphen_glyph(&g[k - 1]).adv;
@@ -500,6 +641,30 @@ fn break_line(text: &str, g: &[SGlyph], i: usize, width: f64, hyphenate: bool) -
     (end, hy)
 }
 
+/// Does kinsoku allow a line break after glyph `j`? Not after an opening bracket, nor before a
+/// closing one, a comma, a full stop, a small kana… (the character is pushed to the next line
+/// with the one before it).
+fn kinsoku_allows(g: &[SGlyph], j: usize) -> bool {
+    g.get(j).is_some_and(|gl| kinsoku_between(gl.ch, g.get(j + 1).map(|n| n.ch)))
+}
+
+/// Kinsoku for a break between `before` and `after` (none: the end of the paragraph).
+fn kinsoku_between(before: char, after: Option<char>) -> bool {
+    !no_line_end(before) && after.is_none_or(|c| !no_line_start(c))
+}
+
+#[cfg(test)]
+#[test]
+fn kinsoku_keeps_closing_marks_off_line_starts_and_opening_ones_off_line_ends() {
+    for (a, b) in [('字', '。'), ('弧', '」'), ('」', '、'), ('ャ', 'ー'), ('カ', 'ッ'), ('「', 'か'), ('（', '雅')] {
+        assert!(!kinsoku_between(a, Some(b)), "{a}{b}");
+    }
+    for (a, b) in [('。', '雅'), ('」', 'は'), ('字', '「'), ('の', '演')] {
+        assert!(kinsoku_between(a, Some(b)), "{a}{b}");
+    }
+    assert!(kinsoku_between('。', None));
+}
+
 /// Glyph indices inside `g[ws..we]` (a word) where a hyphenated break may go.
 fn hyphen_breaks(text: &str, g: &[SGlyph], ws: usize, we: usize) -> Vec<usize> {
     // Strip leading/trailing punctuation (quotes, commas).
@@ -534,19 +699,19 @@ fn candidates(text: &str, g: &[SGlyph], hyphenate: bool) -> Vec<Breakpoint> {
         let end_of_word = gl.is_space() || gl.break_after();
         if end_of_word {
             if hyphenate && j > ws {
-                for k in hyphen_breaks(text, g, ws, j) {
+                for k in hyphen_breaks(text, g, ws, j).into_iter().filter(|&k| k > 0 && kinsoku_allows(g, k - 1)) {
                     v.push(Breakpoint { end: k, hyphen: hyphen_glyph(&g[k - 1]).adv });
                 }
             }
             let hy = if gl.is_soft_hyphen() { hyphen_glyph(gl).adv } else { 0.0 };
-            if j + 1 < g.len() && g[j + 1].byte != gl.byte {
+            if j + 1 < g.len() && g[j + 1].byte != gl.byte && kinsoku_allows(g, j) {
                 v.push(Breakpoint { end: j + 1, hyphen: hy });
             }
             ws = j + 1;
         }
     }
     if hyphenate && g.len() > ws {
-        for k in hyphen_breaks(text, g, ws, g.len()) {
+        for k in hyphen_breaks(text, g, ws, g.len()).into_iter().filter(|&k| k > 0 && kinsoku_allows(g, k - 1)) {
             v.push(Breakpoint { end: k, hyphen: hyphen_glyph(&g[k - 1]).adv });
         }
     }
@@ -670,8 +835,11 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
                     // Composed lines may shrink word spaces (never below zero).
                     per_space =
                         ((width - w) / spaces as f64).max(-sg[i..trimmed].iter().filter(|g| g.is_space()).map(|g| g.adv).fold(f64::MAX, f64::min));
-                } else if para.justify == Justify::JustifyAll && trimmed - i > 1 && width > w {
-                    per_gap = (width - w) / (trimmed - i - 1) as f64;
+                } else if para.justify == Justify::JustifyAll && width > w {
+                    let gaps = sg.get(i + 1..trimmed).map_or(0, |s| s.iter().filter(|g| !g.continues_tcy()).count());
+                    if gaps > 0 {
+                        per_gap = (width - w) / gaps as f64;
+                    }
                 }
             }
             let start_x = if justify {
@@ -702,7 +870,8 @@ fn flow(cx: &mut Ctx<'_>, paras: &[Range<usize>], para: &ParaStyle, regions: Opt
                 } else if j < trimmed {
                     if g.is_space() {
                         adv += per_space;
-                    } else if j + 1 < trimmed {
+                    } else if j + 1 < trimmed && sg.get(j + 1).is_some_and(|next| !next.continues_tcy()) {
+                        // Between glyphs, never inside a tate-chu-yoko block (one cell).
                         adv += per_gap;
                     }
                 }

crates/text/src/lib.rs

@@ -10,6 +10,7 @@
 #![forbid(unsafe_code)]
 
 mod composer;
+pub mod craft_fonts;
 pub mod edit;
 pub mod embed;
 mod features;
@@ -17,10 +18,13 @@ mod fontdb;
 pub mod hyphen;
 mod layout;
 mod shape;
+#[cfg(any(test, feature = "test-fonts"))]
+pub mod test_fonts;
 pub mod thread;
 
+pub use craft_fonts::{CRAFT_FONTS, CraftFont};
 pub use features::OtFeatures;
-pub use fontdb::{FALLBACK_FAMILY, FontDb, FontFace, style_weight, system_font_dirs};
+pub use fontdb::{FALLBACK_FAMILY, FontDb, FontFace, FontMatch, style_weight, system_font_dirs};
 use kurbo::{Affine, BezPath, Point, Rect, Vec2};
 pub use layout::{layout, layout_with};
 pub use vectorcraft_doc::TextObject;
@@ -124,6 +128,11 @@ pub struct LineInfo {
 
 #[derive(Clone, Debug, Default)]
 pub struct TextLayout {
+    /// Lines retain inline/block coordinates; glyph geometry is in physical text space.
+    pub vertical: bool,
+    /// Inline/block (line) space → physical text space: identity for horizontal type, a quarter
+    /// turn clockwise for vertical type (point type also centres its first column on the anchor).
+    pub line_xf: Affine,
     pub glyphs: Vec<PositionedGlyph>,
     pub lines: Vec<LineInfo>,
     /// Ink/advance bounds in text space.
@@ -138,6 +147,13 @@ pub struct TextLayout {
 }
 
 impl TextLayout {
+    /// Convert physical text coordinates to inline/block coordinates.
+    pub fn logical_point(&self, p: Point) -> Point {
+        if self.vertical { self.line_xf.inverse() * p } else { p }
+    }
+    pub fn physical_point(&self, p: Point) -> Point {
+        if self.vertical { self.line_xf * p } else { p }
+    }
     /// All glyph outlines combined (e.g. for Create Outlines).
     pub fn to_bezpath(&self) -> BezPath {
         let mut p = BezPath::new();
@@ -157,7 +173,7 @@ impl TextLayout {
     /// the layout changed.
     pub fn snap_to_pixels(&mut self, to_device: Affine) -> bool {
         let [a, b, c, d, _, _] = to_device.as_coeffs();
-        if self.on_path || b.abs() > 1e-9 || c.abs() > 1e-9 || a.abs() < 1e-12 || d.abs() < 1e-12 {
+        if self.on_path || self.vertical || b.abs() > 1e-9 || c.abs() > 1e-9 || a.abs() < 1e-12 || d.abs() < 1e-12 {
             return false;
         }
         let mut moved = false;
@@ -192,7 +208,7 @@ pub fn caret_position(layout: &TextLayout, byte: usize) -> (Point, Point) {
     } else if let Some(g) = glyphs.last() {
         (g.origin + dir(g.angle) * g.advance, g.angle)
     } else {
-        (Point::new(line.x0, line.baseline), 0.0)
+        (layout.physical_point(Point::new(line.x0, line.baseline)), if layout.vertical { std::f64::consts::FRAC_PI_2 } else { 0.0 })
     };
     // Up vector in y-down space, rotated with the baseline.
     let d = dir(angle);
@@ -214,6 +230,7 @@ pub fn hit_byte(layout: &TextLayout, p: Point) -> usize {
             None => layout.lines.first().map_or(0, |l| l.start),
         };
     }
+    let p = layout.logical_point(p);
     // Nearest line band (vertical distance first, then distance to the line's column).
     let dist = |l: &LineInfo| {
         let dy = if p.y < l.baseline - l.ascent {
@@ -247,7 +264,7 @@ pub fn hit_byte(layout: &TextLayout, p: Point) -> usize {
 pub fn byte_in_line(layout: &TextLayout, li: usize, x: f64) -> usize {
     let Some(line) = layout.lines.get(li) else { return 0 };
     let glyphs = &layout.glyphs[line.glyph_start..line.glyph_end];
-    if let Some(g) = glyphs.iter().find(|g| x < g.origin.x + g.advance * 0.5) {
+    if let Some(g) = glyphs.iter().find(|g| x < layout.logical_point(g.origin).x + g.advance * 0.5) {
         return g.byte;
     }
     line_end(layout, li)
@@ -281,9 +298,9 @@ fn x_in_line(layout: &TextLayout, li: usize, byte: usize) -> f64 {
     let glyphs = &layout.glyphs[line.glyph_start..line.glyph_end];
     if let Some(g) = glyphs.iter().find(|g| g.byte + g.len > byte) {
         let frac = if byte <= g.byte { 0.0 } else { (byte - g.byte) as f64 / g.len.max(1) as f64 };
-        return g.origin.x + g.advance * frac;
+        return layout.logical_point(g.origin).x + g.advance * frac;
     }
-    glyphs.last().map_or(line.x0, |g| g.origin.x + g.advance)
+    glyphs.last().map_or(line.x0, |g| layout.logical_point(g.origin).x + g.advance)
 }
 
 /// Move the caret `delta` lines up (negative) or down, keeping horizontal position `goal_x`
@@ -345,14 +362,14 @@ pub fn selection_quads(layout: &TextLayout, a: usize, b: usize) -> Vec<[Point; 4
         let mut xb = x_in_line(layout, li, b.min(l.end));
         if b > l.end {
             // The selection continues past the line: include the line break / trailing space.
-            let last = layout.glyphs[l.glyph_start..l.glyph_end].last().map_or(l.x1, |g| g.origin.x + g.advance);
+            let last = layout.glyphs[l.glyph_start..l.glyph_end].last().map_or(l.x1, |g| layout.logical_point(g.origin).x + g.advance);
             xb = last.max(l.x1) + (l.ascent + l.descent) * 0.25;
         }
         if xb - xa <= 1e-9 {
             continue;
         }
         let (t, bt) = (l.baseline - l.ascent, l.baseline + l.descent);
-        out.push([Point::new(xa, t), Point::new(xb, t), Point::new(xb, bt), Point::new(xa, bt)]);
+        out.push([Point::new(xa, t), Point::new(xb, t), Point::new(xb, bt), Point::new(xa, bt)].map(|p| layout.physical_point(p)));
     }
     out
 }
@@ -369,3 +386,7 @@ mod tests_snap;
 mod tests_sysfonts;
 #[cfg(test)]
 mod tests_typo;
+#[cfg(test)]
+mod tests_variable;
+#[cfg(test)]
+mod tests_vertical;

crates/text/src/shape.rs

@@ -5,7 +5,7 @@ use std::sync::Arc;
 
 use harfrust::{Direction, Feature, ShapeOptions, UnicodeBuffer};
 use skrifa::MetadataProvider;
-use skrifa::instance::{LocationRef, Size};
+use skrifa::instance::Size;
 use vectorcraft_doc::CharStyle;
 
 use crate::features::OtFeatures;
@@ -40,6 +40,22 @@ pub(crate) struct SGlyph {
     pub xh: f64,
     /// First source character of the cluster.
     pub ch: char,
+    /// Vertical type: part of a tate-chu-yoko block (set across the column, upright).
+    pub tcy: Option<Tcy>,
+}
+
+/// A glyph's place in a tate-chu-yoko block: the block takes one em of the column, its glyphs side
+/// by side across it.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub(crate) struct Tcy {
+    /// Laid-out distance from the block's start to this glyph's pen position.
+    pub pen: f64,
+    /// Distance from the block's start to the glyph in the block's own (horizontal) setting.
+    pub ink: f64,
+    /// Width of the block's own setting.
+    pub width: f64,
+    /// Horizontal scale that fits the block into one em (1 when it fits as it is).
+    pub squeeze: f64,
 }
 
 impl SGlyph {
@@ -58,6 +74,10 @@ impl SGlyph {
     pub fn is_letter(&self) -> bool {
         self.ch.is_alphabetic() || matches!(self.ch, '\'' | '’')
     }
+    /// Vertical type: a tate-chu-yoko glyph after its block's first, sharing that glyph's cell.
+    pub fn continues_tcy(&self) -> bool {
+        self.tcy.is_some_and(|t| t.pen > 0.0)
+    }
 }
 
 pub(crate) const SOFT_HYPHEN: char = '\u{00AD}';
@@ -77,6 +97,46 @@ pub(crate) fn hyphen_glyph(g: &SGlyph) -> SGlyph {
     h
 }
 
+/// Kinsoku (Japanese line breaking, the strict set): a character that can't start a line —
+/// closing brackets, the Japanese comma and full stop, middle dots, colons, ! and ?, the long
+/// vowel mark, iteration marks and small kana.
+pub(crate) fn no_line_start(c: char) -> bool {
+    matches!(c,
+        ')' | ']' | '}' | ',' | '.' | ':' | ';' | '!' | '?' | '»' | '’' | '”' | '‐' | '–' | '‼' | '⁇' | '⁈' | '⁉'
+        | '、' | '。' | '〉' | '》' | '」' | '』' | '】' | '〕' | '〗' | '〙' | '〛' | '〟' | '〜' | '゠' | '・' | '｠'
+        | 'ー' | 'ゝ' | 'ゞ' | 'ヽ' | 'ヾ' | '々' | '〻'
+        | 'ぁ' | 'ぃ' | 'ぅ' | 'ぇ' | 'ぉ' | 'っ' | 'ゃ' | 'ゅ' | 'ょ' | 'ゎ' | 'ゕ' | 'ゖ'
+        | 'ァ' | 'ィ' | 'ゥ' | 'ェ' | 'ォ' | 'ッ' | 'ャ' | 'ュ' | 'ョ' | 'ヮ' | 'ヵ' | 'ヶ' | 'ㇰ'..='ㇿ'
+        | '！' | '）' | '，' | '．' | '：' | '；' | '？' | '］' | '｝' | '～' | '｡' | '｣' | '､' | '･' | 'ｰ' | 'ｧ'..='ｯ')
+}
+
+/// Kinsoku: a character that can't end a line (opening brackets).
+pub(crate) fn no_line_end(c: char) -> bool {
+    matches!(
+        c,
+        '(' | '['
+            | '{'
+            | '«'
+            | '‘'
+            | '“'
+            | '〈'
+            | '《'
+            | '「'
+            | '『'
+            | '【'
+            | '〔'
+            | '〖'
+            | '〘'
+            | '〚'
+            | '〝'
+            | '（'
+            | '［'
+            | '｛'
+            | '｟'
+            | '｢'
+    )
+}
+
 fn is_cjk(c: char) -> bool {
     matches!(c as u32, 0x2E80..=0x9FFF | 0xAC00..=0xD7AF | 0xF900..=0xFAFF | 0xFF00..=0xFFEF | 0x20000..=0x2FFFF)
 }
@@ -187,7 +247,7 @@ fn shape_segment(text: &str, seg: &Segment, feats: &OtFeatures, out: &mut Vec<SG
 
     let mut raw: Vec<(u32, u32, i32, i32, i32)> = Vec::with_capacity(text_seg.len()); // gid, cluster, xadv, xoff, yoff
     let shaped = face.hb().map(|hb| {
-        let shaper = face.shaper.shaper(&hb).build();
+        let shaper = face.shaper.shaper(&hb).instance(face.instance.as_ref()).build();
         let mut buf = UnicodeBuffer::new();
         for (i, c) in text_seg.char_indices() {
             let cl = (range.start + i) as u32;
@@ -211,7 +271,7 @@ fn shape_segment(text: &str, seg: &Segment, feats: &OtFeatures, out: &mut Vec<SG
         // Fallback: nominal glyphs and hmtx advances, no shaping.
         if let Some(f) = face.skrifa() {
             let cmap = f.charmap();
-            let gm = f.glyph_metrics(Size::unscaled(), LocationRef::default());
+            let gm = f.glyph_metrics(Size::unscaled(), face.location());
             for (i, c) in text_seg.char_indices() {
                 let cl = (range.start + i) as u32;
                 let chars: Vec<char> = if upper { c.to_uppercase().collect() } else { vec![c] };
@@ -255,6 +315,7 @@ fn shape_segment(text: &str, seg: &Segment, feats: &OtFeatures, out: &mut Vec<SG
             cap,
             xh,
             ch,
+            tcy: None,
         });
     }
 }

crates/text/src/test_fonts.rs

@@ -0,0 +1,112 @@
+//! Fonts built in code for tests, so no font file is committed: a small variable font (#296).
+//! Compiled for this crate's tests and, with the `test-fonts` feature, for other crates' tests.
+
+use skrifa::instance::{LocationRef, Size};
+use skrifa::raw::TableProvider;
+use skrifa::raw::tables::glyf::Glyph;
+use skrifa::{GlyphId, MetadataProvider};
+use write_fonts::FontBuilder;
+use write_fonts::tables::fvar::{AxisInstanceArrays, Fvar, InstanceRecord, VariationAxisRecord};
+use write_fonts::tables::gvar::{GlyphDelta, GlyphDeltas, GlyphVariations, Gvar, Tent};
+use write_fonts::types::{F2Dot14, Fixed, NameId, Tag};
+
+/// The family of [`variable_font`].
+pub const VARIABLE_FAMILY: &str = "Varitest Sans";
+
+/// The characters [`variable_font`] widens towards its heaviest weight (simple glyphs in Source Sans
+/// 3; the composite ones, like `H`, would need their components varied).
+pub const VARIABLE_CHARS: &str = "lIn";
+
+/// How much wider [`VARIABLE_CHARS`] are at the heaviest weight (outlines and advances).
+pub const VARIABLE_WIDEN: f32 = 0.25;
+
+/// The bundled Source Sans 3 Regular as a variable font of family [`VARIABLE_FAMILY`]: one weight
+/// axis (400–700, default 400, the face itself being Regular) whose maximum makes the glyphs of
+/// [`VARIABLE_CHARS`] [`VARIABLE_WIDEN`] wider (outlines and advances, through `gvar`), with the
+/// named instances Normal (the default, the face Regular), SemiBold (550) and Bold (700), plus an instance without
+/// a name and one named like another (`BOLD`), which style lists leave out. `None` when it can't
+/// be built.
+pub fn variable_font() -> Option<Vec<u8>> {
+    const BASE: &[u8] = include_bytes!("../../../assets/fonts/SourceSans3-Regular.ttf");
+    let font = skrifa::FontRef::new(BASE).ok()?;
+    let (glyf, loca) = (font.glyf().ok()?, font.loca(None).ok()?);
+    let metrics = font.glyph_metrics(Size::unscaled(), LocationRef::default());
+    let charmap = font.charmap();
+    let widened: Vec<GlyphId> = VARIABLE_CHARS.chars().filter_map(|c| charmap.map(c)).collect();
+    let mut variations = Vec::new();
+    for g in 0..u32::from(font.maxp().ok()?.num_glyphs()) {
+        let gid = write_fonts::types::GlyphId::new(g);
+        let id = GlyphId::new(g);
+        let deltas = if widened.contains(&id) {
+            let Ok(Some(Glyph::Simple(s))) = loca.get_glyf(id, &glyf) else { return None };
+            let wider = |x: f32| (x * VARIABLE_WIDEN).round() as i16;
+            let mut d: Vec<GlyphDelta> = s.points().map(|p| GlyphDelta::required(wider(f32::from(p.x)), 0)).collect();
+            // The phantom points: left side bearing, advance, top, bottom.
+            let advance = wider(metrics.advance_width(id)?);
+            d.extend([(0, 0), (advance, 0), (0, 0), (0, 0)].map(|(x, y)| GlyphDelta::required(x, y)));
+            vec![GlyphDeltas::new(vec![Tent::new(F2Dot14::from_f32(1.0), None)], d)]
+        } else {
+            vec![]
+        };
+        variations.push(GlyphVariations::new(gid, deltas));
+    }
+    let gvar = Gvar::new(variations, 1).ok()?;
+    let axis = VariationAxisRecord {
+        axis_tag: Tag::new(b"wght"),
+        min_value: Fixed::from_i32(400),
+        default_value: Fixed::from_i32(400),
+        max_value: Fixed::from_i32(700),
+        flags: 0,
+        axis_name_id: NameId::new(256),
+    };
+    let instance = |name: u16, wght: i32| InstanceRecord {
+        subfamily_name_id: NameId::new(name),
+        flags: 0,
+        coordinates: vec![Fixed::from_i32(wght)],
+        post_script_name_id: None,
+    };
+    let instances = vec![instance(257, 400), instance(258, 550), instance(259, 700), instance(260, 600), instance(261, 650)];
+    let fvar = Fvar::new(AxisInstanceArrays::new(vec![axis], instances));
+    let name = name_table(&[
+        (1, VARIABLE_FAMILY),
+        (2, "Regular"),
+        (4, "Varitest Sans Regular"),
+        (6, "VaritestSans-Regular"),
+        (256, "Weight"),
+        (257, "Normal"),
+        (258, "SemiBold"),
+        (259, "Bold"),
+        (261, "BOLD"),
+    ])?;
+    let mut builder = FontBuilder::new();
+    builder.add_raw(Tag::new(b"name"), name);
+    builder.add_table(&fvar).ok()?.add_table(&gvar).ok()?;
+    // The rest of Source Sans 3's tables as they are.
+    for r in font.table_directory.table_records() {
+        let tag = Tag::new(&r.tag().to_be_bytes());
+        if !builder.contains(tag) {
+            builder.add_raw(tag, font.table_data(r.tag())?.as_bytes());
+        }
+    }
+    Some(builder.build())
+}
+
+/// A `name` table of Windows English (US) records (name id, string).
+pub fn name_table(records: &[(u16, &str)]) -> Option<Vec<u8>> {
+    let mut records = records.to_vec();
+    records.sort_by_key(|r| r.0);
+    let n = u16::try_from(records.len()).ok()?;
+    let (mut head, mut strings) = (Vec::new(), Vec::new());
+    for v in [0, n, 6 + 12 * n] {
+        head.extend_from_slice(&v.to_be_bytes());
+    }
+    for (id, s) in records {
+        let bytes: Vec<u8> = s.encode_utf16().flat_map(u16::to_be_bytes).collect();
+        for v in [3, 1, 0x0409, id, u16::try_from(bytes.len()).ok()?, u16::try_from(strings.len()).ok()?] {
+            head.extend_from_slice(&v.to_be_bytes());
+        }
+        strings.extend(bytes);
+    }
+    head.extend(strings);
+    Some(head)
+}

crates/text/src/tests.rs

@@ -421,3 +421,73 @@ fn tab_stops_position_text() {
     p.para.tabs = vec![stop(50.0, TabAlign::Left)];
     assert!((x_of(&p, 4) - 72.0).abs() < 1e-6);
 }
+
+/// Are the Japanese craft-fonts faces built in? Tests of Japanese glyphs skip (and say so) when
+/// they aren't: the bundled fonts have none, and [`db`] reads no system fonts.
+fn japanese_fonts() -> bool {
+    let built_in = CRAFT_FONTS.iter().any(|f| f.is_japanese());
+    if !built_in {
+        eprintln!("skipped: built without craft-fonts (set CRAFT_FONTS_DIR to a craft-fonts checkout to run it)");
+    }
+    built_in
+}
+
+#[test]
+fn japanese_text_uses_the_craft_fonts_mincho_after_the_bundled_fonts() {
+    if !japanese_fonts() {
+        return;
+    }
+    let l = layout(db(), &point("日本語の文字", style(20.0)));
+    assert_eq!(l.glyphs.len(), 6);
+    assert!(l.glyphs.iter().all(|g| g.gid != 0 && !g.outline.elements().is_empty()), "real glyphs, no tofu");
+    let face = db().face_covering('日').unwrap();
+    assert!(face.family.contains("Mincho"), "document text falls back to a Mincho face: {}", face.family);
+    assert!(CRAFT_FONTS.iter().any(|f| f.family == face.family));
+    // Latin keeps the bundled fallback family.
+    assert_eq!(db().face_covering('a').unwrap().family, FALLBACK_FAMILY);
+}
+
+#[test]
+fn japanese_text_lays_out_without_the_craft_fonts() {
+    // Built either way, Japanese text lays out (as missing glyphs when no font has them).
+    let l = layout(db(), &point("日本語の文字 abc", style(20.0)));
+    assert_eq!(l.lines.len(), 1);
+    assert!(l.glyphs.iter().all(|g| g.advance.is_finite()));
+    if CRAFT_FONTS.is_empty() {
+        assert!(db().families().iter().all(|f| !f.contains("Mincho") && !f.contains("Gothic")), "no Japanese font is bundled");
+    }
+}
+
+#[test]
+fn vertical_japanese_columns_have_upright_ink_and_edit_geometry() {
+    if !japanese_fonts() {
+        return;
+    }
+    let mut t = point("日本語\n縦書き", style(30.0));
+    t.vertical = true;
+    let l = layout(db(), &t);
+    assert!(l.vertical);
+    assert_eq!(l.lines.len(), 2);
+    assert!(l.glyphs.iter().all(|g| g.gid != 0 && !g.outline.elements().is_empty()));
+    assert!(l.glyphs[3].origin.x < l.glyphs[0].origin.x);
+    assert!(l.glyphs[1].origin.y > l.glyphs[0].origin.y);
+    for g in &l.glyphs {
+        let p = g.origin + dir(g.angle) * (g.advance * 0.1);
+        assert_eq!(hit_byte(&l, p), g.byte);
+        let (a, b) = caret_position(&l, g.byte);
+        assert!((a.y - b.y).abs() < 1e-6);
+        assert!(a.x > b.x);
+    }
+    let selection = selection_quads(&l, 0, "日本語".len());
+    assert_eq!(selection.len(), 1);
+}
+
+#[test]
+fn vertical_area_type_wraps_into_columns_inside_the_frame() {
+    let mut t = area("日本語日本語日本語", style(20.0), Rect::new(0.0, 0.0, 100.0, 65.0), Justify::Left);
+    t.vertical = true;
+    let l = layout(db(), &t);
+    assert!(l.lines.len() > 1);
+    assert!(l.glyphs.iter().all(|g| g.origin.x >= 0.0 && g.origin.x <= 100.0 && g.origin.y >= 0.0 && g.origin.y <= 65.0));
+    assert!(l.glyphs[l.lines[1].glyph_start].origin.x < l.glyphs[0].origin.x);
+}

crates/text/src/tests_sysfonts.rs

@@ -9,9 +9,15 @@ const FAMILY: &str = "Sysfont Sans3";
 
 /// A bundled Source Sans 3 file renamed [`FAMILY`] (as long as the original name).
 fn renamed(file: &str) -> Vec<u8> {
+    renamed_to(file, FAMILY)
+}
+
+/// A bundled Source Sans 3 file renamed `family`, which is as long as the original name.
+fn renamed_to(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())] {
+    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);
@@ -132,6 +138,30 @@ fn the_family_list_is_shared_until_fonts_change() {
     assert!(!Arc::ptr_eq(&a, &b) && has(&b, FAMILY) && !has(&a, FAMILY));
 }
 
+#[test]
+fn font_lists_leave_out_hidden_system_families_which_still_resolve() {
+    // macOS names the faces it keeps for its own interface with a leading "." (".SF NS").
+    const HIDDEN: &str = ".Sysfont Sans";
+    const DOTTED: &str = "Sysfont.Sans3";
+    let dir = font_dir("hidden");
+    std::fs::write(dir.join("Hidden.ttf"), renamed_to("SourceSans3-Regular.ttf", HIDDEN)).unwrap();
+    std::fs::write(dir.join("Dotted.ttf"), renamed_to("SourceSans3-Regular.ttf", DOTTED)).unwrap();
+    let db = FontDb::with_font_dirs(vec![dir]);
+    let listed = db.menu_family_list();
+    assert!(has(&listed, FAMILY) && has(&listed, FALLBACK_FAMILY));
+    assert!(!has(&listed, HIDDEN), "a leading dot hides a family: {listed:?}");
+    assert!(has(&listed, DOTTED), "a dot elsewhere doesn't");
+    assert_eq!(listed.len() + 1, db.family_list().len(), "only the hidden family is left out");
+    assert!(Arc::ptr_eq(&listed, &db.menu_family_list()), "shared until the fonts change");
+    // Documents and fallbacks that name it still find it.
+    assert!(has(&db.families(), HIDDEN) && db.has_family(HIDDEN));
+    assert_eq!(db.find_family(HIDDEN).as_deref(), Some(HIDDEN));
+    assert_eq!(db.face(HIDDEN, "Regular").unwrap().family, HIDDEN);
+    // Loading it changed the fonts: the list is built again, still without it.
+    let again = db.menu_family_list();
+    assert!(!Arc::ptr_eq(&listed, &again) && *listed == *again);
+}
+
 #[test]
 fn installed_styles_of_a_loaded_family_load_when_asked_for() {
     let dir = font_dir("styles");
@@ -142,3 +172,15 @@ fn installed_styles_of_a_loaded_family_load_when_asked_for() {
     // A style nobody has still gets the closest one.
     assert_eq!(db.face(FAMILY, "Black").unwrap().style, "Bold");
 }
+
+/// Documents name fonts by PostScript name, and families can hold hyphens: the installed face of
+/// that exact name gives the family and style, however the name splits.
+#[test]
+fn installed_faces_are_found_by_postscript_name() {
+    let dir = font_dir("postscript");
+    let db = FontDb::with_font_dirs(vec![dir]);
+    // The renamed Source Sans 3 files keep their PostScript names.
+    assert_eq!(db.by_postscript_name("SourceSans3-Bold"), Some((FAMILY.to_string(), "Bold".to_string())));
+    assert_eq!(db.by_postscript_name("sourcesans3-regular"), Some((FAMILY.to_string(), "Regular".to_string())), "any case");
+    assert_eq!(db.by_postscript_name("Rounded-X-Mplus-1c-black"), None);
+}

crates/text/src/tests_variable.rs

@@ -0,0 +1,248 @@
+//! Variable fonts: each named instance is a style of its own, listed, resolved, shaped, drawn and
+//! embedded at its axis settings (#296: Figtree listed only Light, its default instance).
+
+use kurbo::{Point, Shape};
+use skrifa::MetadataProvider;
+use skrifa::instance::{LocationRef, Size};
+use skrifa::raw::TableProvider;
+use vectorcraft_doc::CharStyle;
+
+use super::test_fonts::{VARIABLE_CHARS, VARIABLE_FAMILY as FAMILY, VARIABLE_WIDEN, name_table, variable_font};
+use super::*;
+
+fn font() -> Vec<u8> {
+    variable_font().expect("the test font builds")
+}
+
+/// A database of the bundled fonts and the test variable font.
+fn db() -> FontDb {
+    let db = FontDb::with_font_dirs(vec![]);
+    assert_eq!(db.add_font(font()), 3, "Regular, SemiBold and Bold");
+    db
+}
+
+/// The width of `c`'s outline in font units.
+fn ink_width(db: &FontDb, face: &FontFace, c: char) -> f64 {
+    db.outline(face, face.glyph_for(c)).bounding_box().width()
+}
+
+fn text(family: &str, style: &str, s: &str) -> TextObject {
+    TextObject::point(Point::ZERO, s, CharStyle { font_family: family.into(), font_style: style.into(), size: 100.0, ..CharStyle::default() })
+}
+
+#[test]
+fn named_instances_are_styles_of_the_family() {
+    let db = db();
+    // The default instance is the face itself; the unnamed and the twice-named ones are left out.
+    assert_eq!(db.styles(FAMILY), ["Regular", "SemiBold", "Bold"]);
+    let bold = db.face(FAMILY, "Bold").unwrap();
+    assert_eq!((bold.family.as_str(), bold.style.as_str(), bold.weight, bold.italic), (FAMILY, "Bold", 700.0, false));
+    assert_eq!(bold.variations(), [(*b"wght", 700.0)]);
+    let regular = db.face(FAMILY, "Regular").unwrap();
+    assert!(regular.variations().is_empty() && regular.weight == 400.0);
+    assert_eq!(db.face(FAMILY, "SemiBold").unwrap().weight, 550.0);
+    // Fonts added again add nothing.
+    assert_eq!(db.add_font(font()), 0);
+}
+
+#[test]
+fn an_instance_is_found_by_its_names_and_by_weight() {
+    let db = db();
+    let m = |f: &str, s: &str| db.resolve(f, s).map(|(face, m)| (face.style.clone(), m)).unwrap();
+    assert_eq!(m(FAMILY, "Bold"), ("Bold".into(), FontMatch::Exact));
+    assert_eq!(m("varitest sans", "semi bold"), ("SemiBold".into(), FontMatch::Exact), "names are normalized");
+    // The default instance's own name names the face.
+    assert_eq!(m(FAMILY, "Normal"), ("Regular".into(), FontMatch::Exact));
+    assert!(!db.styles(FAMILY).contains(&"Normal".to_string()));
+    // A style the font hasn't: the closest weight.
+    assert_eq!(m(FAMILY, "Black"), ("Bold".into(), FontMatch::Style));
+    assert_eq!(m(FAMILY, "Medium"), ("SemiBold".into(), FontMatch::Style));
+    // PostScript names (as PDF and .ai files name fonts): `<family>-<style>` without spaces.
+    assert_eq!(m("VaritestSans-Bold", "Regular"), ("Bold".into(), FontMatch::Exact));
+    assert_eq!(db.find_postscript("VaritestSans-SemiBold").unwrap().style, "SemiBold");
+}
+
+#[test]
+fn an_instance_draws_and_measures_its_own_glyphs() {
+    let db = db();
+    let (regular, semi, bold) = (db.face(FAMILY, "Regular").unwrap(), db.face(FAMILY, "SemiBold").unwrap(), db.face(FAMILY, "Bold").unwrap());
+    let widen = f64::from(VARIABLE_WIDEN);
+    for c in VARIABLE_CHARS.chars() {
+        let g = regular.glyph_for(c);
+        assert_eq!(bold.glyph_for(c), g);
+        // Advances (gvar phantom points) and outlines: a quarter wider at Bold, half that at SemiBold.
+        let (r, b, s) = (regular.advance(g), bold.advance(g), semi.advance(g));
+        assert!((b - r * (1.0 + widen)).abs() <= 1.0, "{c}: advance {r} -> {b}");
+        assert!((s - r * (1.0 + widen / 2.0)).abs() <= 1.0, "{c}: SemiBold advance {s}");
+        let (ri, bi) = (ink_width(&db, &regular, c), ink_width(&db, &bold, c));
+        assert!((bi - ri * (1.0 + widen)).abs() <= 2.0, "{c}: outline {ri} -> {bi}");
+    }
+    // Characters the axis doesn't change stay as they are.
+    let o = regular.glyph_for('o');
+    assert_eq!(regular.advance(o), bold.advance(o));
+    assert_eq!(db.outline(&regular, o).to_svg(), db.outline(&bold, o).to_svg());
+
+    // Laid out (shaped with the instance): the glyphs come from the Bold face, advance as it does
+    // and are drawn with its outlines (what the canvas, Create Outlines and hit tests use).
+    let (lr, lb) = (layout(&db, &text(FAMILY, "Regular", VARIABLE_CHARS)), layout(&db, &text(FAMILY, "Bold", VARIABLE_CHARS)));
+    assert!(lb.glyphs.iter().all(|g| g.font_id == bold.id()));
+    let width = |l: &TextLayout| l.glyphs.iter().map(|g| g.advance).sum::<f64>();
+    let expected: f64 = VARIABLE_CHARS.chars().map(|c| bold.advance(bold.glyph_for(c))).sum::<f64>() * 100.0 / bold.units_per_em();
+    assert!((width(&lb) - expected).abs() < 0.5, "shaped {} vs {expected}", width(&lb));
+    assert!(width(&lb) > width(&lr) * (1.0 + widen * 0.9));
+    let ink = |l: &TextLayout| l.to_bezpath().bounding_box().width();
+    assert!(ink(&lb) > ink(&lr) * (1.0 + widen * 0.9), "{} vs {}", ink(&lb), ink(&lr));
+}
+
+#[test]
+fn an_embedded_instance_is_a_static_font_of_that_instance() {
+    let db = db();
+    let bold = db.face(FAMILY, "Bold").unwrap();
+    let e = bold.embed(&['l', 'o']).unwrap();
+    assert!(e.subset && !e.cff);
+    let f = skrifa::FontRef::new(&e.data).unwrap();
+    assert!(f.fvar().is_err() && f.gvar().is_err(), "no variations left");
+    let g = f.charmap().map('l').unwrap();
+    let adv = f.glyph_metrics(Size::unscaled(), LocationRef::default()).advance_width(g).unwrap();
+    assert!((f64::from(adv) - bold.advance(bold.glyph_for('l'))).abs() <= 1.0, "the Bold advance: {adv}");
+    // The default face embeds as before.
+    let regular = db.face(FAMILY, "Regular").unwrap();
+    let data = regular.embed(&['l']).unwrap().data;
+    let r = skrifa::FontRef::new(&data).unwrap();
+    let rl = r.glyph_metrics(Size::unscaled(), LocationRef::default()).advance_width(r.charmap().map('l').unwrap()).unwrap();
+    assert!((f64::from(rl) - regular.advance(regular.glyph_for('l'))).abs() <= 1.0 && rl < adv, "{rl} vs {adv}");
+}
+
+#[test]
+fn installed_variable_fonts_list_their_instances_before_loading() {
+    let dir = std::env::temp_dir().join(format!("vc-varfonts-{}", std::process::id()));
+    let _ = std::fs::remove_dir_all(&dir);
+    std::fs::create_dir_all(&dir).unwrap();
+    std::fs::write(dir.join("Varitest[wght].ttf"), font()).unwrap();
+    let db = FontDb::with_font_dirs(vec![dir]);
+    assert_eq!(db.styles(FAMILY), ["Regular", "SemiBold", "Bold"]);
+    assert!(!db.is_loaded(FAMILY), "listed from the name and fvar tables alone");
+    assert_eq!(db.by_postscript_name("VaritestSans-Bold"), Some((FAMILY.to_string(), "Bold".to_string())));
+    let (bold, m) = db.resolve(FAMILY, "Bold").unwrap();
+    assert_eq!((bold.style.as_str(), m), ("Bold", FontMatch::Exact));
+    assert_eq!(bold.variations(), [(*b"wght", 700.0)]);
+    assert!(bold.path().is_some());
+}
+
+/// Damaged or hostile `fvar` tables give fewer styles, never a panic, and the face still works.
+#[test]
+fn damaged_variation_tables_never_panic() {
+    let name = name_table(&[(1, "Broken Var"), (2, "Regular"), (256, "W")]).unwrap();
+    let be = |v: &[u32]| v.iter().flat_map(|x| x.to_be_bytes()).collect::<Vec<u8>>();
+    // Header: version 1.0, axes offset 16, reserved, axis count, axis size 20, instance count,
+    // instance size.
+    let header = |axes: u16, axis_size: u16, instances: u16, instance_size: u16| {
+        let mut h = be(&[0x0001_0000]);
+        for v in [16, 2, axes, axis_size, instances, instance_size] {
+            h.extend(v.to_be_bytes());
+        }
+        h
+    };
+    let axis = |tag: &[u8; 4], min: i32, def: i32, max: i32| {
+        let mut a = tag.to_vec();
+        a.extend(be(&[(min << 16) as u32, (def << 16) as u32, (max << 16) as u32]));
+        a.extend([0, 0, 1, 0]);
+        a
+    };
+    let mut damaged: Vec<Vec<u8>> = vec![
+        vec![],
+        vec![0; 3],
+        header(0xffff, 20, 0xffff, 8),
+        [header(1, 20, 0xffff, 8), axis(b"wght", 100, 400, 900)].concat(),
+        [header(1, 20, 3, 0xffff), axis(b"wght", 100, 400, 900)].concat(),
+        [header(1, 0, 3, 8), axis(b"wght", 100, 400, 900)].concat(),
+        [header(200, 20, 1, 804), vec![0; 4000]].concat(),
+    ];
+    // Many instances (all named): the list is capped.
+    let mut many = [header(1, 20, 2000, 8), axis(b"wght", 0, 0, 30000)].concat();
+    for i in 0..2000u32 {
+        many.extend(be(&[256 << 16, (i + 1) << 16]));
+    }
+    damaged.push(many);
+    for fvar in &damaged {
+        let f = fontdb::sfnt_of(&[(b"name", &name), (b"fvar", fvar)]).unwrap();
+        let styles = fontdb::face_styles(&skrifa::FontRef::new(&f).unwrap());
+        assert!(!styles.is_empty() && styles.len() <= 2, "{} styles", styles.len());
+    }
+    // A real font with a damaged fvar (and its gvar) still loads and lays out.
+    let good = font();
+    let at = |tag: &[u8; 4]| {
+        let tables = u16::from_be_bytes([good[4], good[5]]) as usize;
+        let r = (0..tables).map(|i| 12 + 16 * i).find(|r| &good[*r..*r + 4] == tag).unwrap();
+        let off = u32::from_be_bytes(good[r + 8..r + 12].try_into().unwrap()) as usize;
+        let len = u32::from_be_bytes(good[r + 12..r + 16].try_into().unwrap()) as usize;
+        off..off + len
+    };
+    let (fvar, gvar) = (at(b"fvar"), at(b"gvar"));
+    // Deterministic byte damage across both tables.
+    let mut seed = 0x2545_f491_u32;
+    for round in 0..300 {
+        let mut bad = good.clone();
+        for _ in 0..1 + round % 8 {
+            seed ^= seed << 13;
+            seed ^= seed >> 17;
+            seed ^= seed << 5;
+            let range = if seed.is_multiple_of(2) { fvar.clone() } else { gvar.clone() };
+            let i = range.start + (seed as usize >> 3) % range.len();
+            bad[i] = (seed >> 24) as u8;
+        }
+        let db = FontDb::with_font_dirs(vec![]);
+        db.add_font(bad);
+        for style in db.styles(FAMILY) {
+            let l = layout(&db, &text(FAMILY, &style, "lHio"));
+            assert!(l.glyphs.len() <= 8, "{style}: {} glyphs", l.glyphs.len());
+        }
+    }
+}
+
+/// Windows ships variable system fonts: Bahnschrift (weight and width axes) lists its named
+/// instances and draws them. Skipped where it isn't installed.
+#[test]
+fn bahnschrift_lists_and_draws_its_instances() {
+    let db = FontDb::with_font_dirs(system_font_dirs());
+    if !db.has_family("Bahnschrift") {
+        eprintln!("skipped: Bahnschrift is not installed");
+        return;
+    }
+    let styles = db.styles("Bahnschrift");
+    eprintln!("Bahnschrift: {styles:?}");
+    for s in ["Light", "Regular", "SemiBold", "Bold"] {
+        assert!(styles.iter().any(|x| x == s), "{s} in {styles:?}");
+    }
+    let light = db.face("Bahnschrift", "Light").unwrap();
+    let bold = db.face("Bahnschrift", "Bold").unwrap();
+    assert_eq!((light.style.as_str(), bold.style.as_str()), ("Light", "Bold"));
+    assert!(bold.weight > light.weight, "{} vs {}", bold.weight, light.weight);
+    let (lw, bw) = (ink_width(&db, &light, 'l'), ink_width(&db, &bold, 'l'));
+    assert!(bw > lw * 1.05, "the Bold l is wider: {lw} -> {bw}");
+    let w = |s: &str| layout(&db, &text("Bahnschrift", s, "Hamburgefonstiv")).to_bezpath().bounding_box().width();
+    assert!(w("Bold") > w("Light"), "{} vs {}", w("Bold"), w("Light"));
+}
+
+/// Segoe UI Variable (Windows 11; optical size and weight axes). Skipped where it isn't installed.
+#[test]
+fn segoe_ui_variable_lists_its_instances() {
+    let db = FontDb::with_font_dirs(system_font_dirs());
+    let families: Vec<String> = db.families().into_iter().filter(|f| f.starts_with("Segoe UI Variable")).collect();
+    if families.is_empty() {
+        eprintln!("skipped: Segoe UI Variable is not installed");
+        return;
+    }
+    for f in &families {
+        let styles = db.styles(f);
+        eprintln!("{f}: {styles:?}");
+        assert!(styles.len() > 1, "{f}: {styles:?}");
+    }
+    if families.iter().any(|f| f == "Segoe UI Variable") {
+        let (light, bold) = (db.face("Segoe UI Variable", "Light Text").unwrap(), db.face("Segoe UI Variable", "Bold Text").unwrap());
+        assert_eq!((light.style.as_str(), bold.style.as_str()), ("Light Text", "Bold Text"));
+        assert!(bold.weight > light.weight && !bold.variations().is_empty());
+        let w = |f: &FontFace| ink_width(&db, f, 'm');
+        assert!(w(&bold) > w(&light), "{} vs {}", w(&bold), w(&light));
+    }
+}

crates/text/src/tests_vertical.rs

@@ -0,0 +1,263 @@
+//! Vertical type (bundled fonts: `§` and `×` stand upright like CJK, letters lie on their side;
+//! Japanese text only with craft-fonts' faces, skipped without them).
+use super::*;
+use kurbo::Shape;
+use vectorcraft_doc::{CharStyle, Justify, TextKind};
+use vectorcraft_geom::PathData;
+
+fn vertical(text: &str) -> TextObject {
+    vertical_styled(text, CharStyle { size: 20.0, ..CharStyle::default() })
+}
+
+fn vertical_styled(text: &str, style: CharStyle) -> TextObject {
+    let mut t = TextObject::point(Point::ZERO, text, style);
+    t.xf = Affine::IDENTITY;
+    t.vertical = true;
+    t
+}
+
+fn ink(l: &TextLayout, i: usize) -> Rect {
+    l.glyphs[i].outline.bounding_box()
+}
+
+#[test]
+fn columns_run_down_and_follow_each_other_to_the_left() {
+    let l = layout(FontDb::global(), &vertical("§§\n§"));
+    assert!(l.vertical);
+    let (a, b, c) = (ink(&l, 0), ink(&l, 1), ink(&l, 2));
+    assert!(b.center().y > a.center().y + 15.0, "down the column: {a:?} {b:?}");
+    assert!((a.center().x - b.center().x).abs() < 0.5, "one column");
+    assert!(c.center().x < a.center().x - 15.0, "the next column is to the left: {c:?}");
+    // Point type: the anchor is on the first column's centre line.
+    assert!(a.center().x.abs() < 4.0, "{a:?}");
+    assert!(l.bounds.contains(a.center()) && l.bounds.contains(c.center()));
+}
+
+#[test]
+fn upright_marks_stand_and_letters_lie_on_their_side() {
+    let h = layout(FontDb::global(), &TextObject::point(Point::ZERO, "§l", CharStyle { size: 20.0, ..CharStyle::default() }));
+    let v = layout(FontDb::global(), &vertical("§l"));
+    let (hs, hl, vs, vl) = (ink(&h, 0), ink(&h, 1), ink(&v, 0), ink(&v, 1));
+    assert!((vs.width() - hs.width()).abs() < 0.01 && (vs.height() - hs.height()).abs() < 0.01, "§ upright: {hs:?} {vs:?}");
+    assert!((vl.width() - hl.height()).abs() < 0.01 && (vl.height() - hl.width()).abs() < 0.01, "l turned: {hl:?} {vl:?}");
+    assert!(vl.width() > vl.height(), "a tall l lies across the column");
+}
+
+#[test]
+fn caret_and_selection_turn_with_the_columns() {
+    let l = layout(FontDb::global(), &vertical("§§§"));
+    let (top, bottom) = caret_position(&l, "§".len());
+    assert!((top.y - bottom.y).abs() < 1e-6 && (top.x - bottom.x).abs() > 10.0, "a horizontal caret across the column: {top:?} {bottom:?}");
+    let between = (ink(&l, 0).center().y + ink(&l, 1).center().y) / 2.0;
+    assert!((top.y - between).abs() < 3.0, "between the first two marks: {top:?} {between} {:?} {:?}", ink(&l, 0), ink(&l, 1));
+    let q = selection_quads(&l, 0, "§§".len());
+    let r = Rect::from_points(q[0][0], q[0][2]);
+    assert!(r.height() > r.width() && r.contains(ink(&l, 0).center()) && r.contains(ink(&l, 1).center()) && !r.contains(ink(&l, 2).center()));
+    // Clicking a mark finds it.
+    let c = ink(&l, 2).center();
+    assert_eq!(hit_byte(&l, c + Vec2::new(0.0, 6.0)), "§§§".len());
+    assert_eq!(hit_byte(&l, c - Vec2::new(0.0, 6.0)), "§§".len());
+}
+
+#[test]
+fn area_type_starts_at_the_right_edge_and_wraps_to_the_left() {
+    let mut t = vertical(&"§".repeat(12));
+    t.kind = TextKind::Area { frame: PathData::from_bezpath(&Rect::new(0.0, 0.0, 100.0, 105.0).to_path(0.1)) };
+    let l = layout(FontDb::global(), &t);
+    let first = ink(&l, 0);
+    assert!(first.x1 <= 100.0 + 1e-6 && first.x1 > 80.0 && first.y0 >= 0.0, "top right: {first:?}");
+    let cols: Vec<f64> = l.glyphs.iter().map(|g| (g.outline.bounding_box().center().x * 10.0).round()).collect();
+    let mut distinct = cols.clone();
+    distinct.dedup();
+    assert!(distinct.len() >= 2 && distinct.windows(2).all(|w| w[1] < w[0]), "columns right to left: {distinct:?}");
+    assert!(l.glyphs.iter().all(|g| g.outline.bounding_box().y1 <= 105.0 + 1e-6), "inside the frame");
+}
+
+#[test]
+fn type_on_a_path_stays_horizontal() {
+    let mut t = vertical("ab");
+    t.kind = TextKind::OnPath { path: PathData::from_bezpath(&kurbo::Line::new((0.0, 0.0), (100.0, 0.0)).to_path(0.1)), start: 0.0 };
+    assert!(!layout(FontDb::global(), &t).vertical);
+}
+
+#[test]
+fn three_digits_stand_across_the_column_squeezed_into_one_em() {
+    let l = layout(FontDb::global(), &vertical("§100§"));
+    let block: Vec<Rect> = (1..4).map(|i| ink(&l, i)).collect();
+    assert!(block.windows(2).all(|w| w[1].center().x > w[0].center().x + 2.0 && (w[1].center().y - w[0].center().y).abs() < 1.0), "{block:?}");
+    let span = block[0].union(block[2]);
+    assert!(span.width() <= 20.0 + 1e-6, "squeezed into the 20 pt em: {span:?}");
+    assert!(ink(&l, 4).center().y - ink(&l, 0).center().y < 45.0, "one em of the column");
+}
+
+#[test]
+fn two_digits_stand_across_the_column_and_longer_numbers_lie_on_their_side() {
+    let l = layout(FontDb::global(), &vertical("§12§2026"));
+    let (one, two) = (ink(&l, 1), ink(&l, 2));
+    assert!((one.center().y - two.center().y).abs() < 1.0 && two.center().x > one.center().x + 3.0, "12 side by side: {one:?} {two:?}");
+    assert!(one.height() > one.width(), "upright digits are taller than wide: {one:?}");
+    let (before, after) = (ink(&l, 0), ink(&l, 3));
+    assert!(after.center().y - before.center().y < 45.0, "the block takes one em (20 pt) of the column");
+    let year: Vec<Rect> = (4..8).map(|i| ink(&l, i)).collect();
+    assert!(year.windows(2).all(|w| w[1].center().y > w[0].center().y + 5.0), "2026 runs down the column on its side");
+}
+
+/// Each line's text, from the layout's line ranges.
+fn line_texts(t: &TextObject, l: &TextLayout) -> Vec<String> {
+    let text = t.plain_text();
+    l.lines.iter().map(|li| text.get(li.start..li.end).unwrap_or("").trim_end().to_string()).collect()
+}
+
+#[test]
+fn kinsoku_keeps_closing_marks_off_line_starts_and_opening_brackets_off_line_ends() {
+    for vertical_type in [false, true] {
+        // Five characters fit a line: without kinsoku "。" would start the second line.
+        let text = "あいうえお。かきくけ「こさしすせそ」";
+        let mut t = TextObject::point(Point::ZERO, text, CharStyle { size: 20.0, ..CharStyle::default() });
+        t.xf = Affine::IDENTITY;
+        t.kind = TextKind::Area { frame: PathData::from_bezpath(&Rect::new(0.0, 0.0, 101.0, 400.0).to_path(0.1)) };
+        if vertical_type {
+            t.kind = TextKind::Area { frame: PathData::from_bezpath(&Rect::new(0.0, 0.0, 400.0, 101.0).to_path(0.1)) };
+            t.vertical = true;
+        }
+        let l = layout(FontDb::global(), &t);
+        let lines = line_texts(&t, &l);
+        assert!(lines.len() > 2, "{lines:?}");
+        for (i, line) in lines.iter().enumerate() {
+            if i > 0 {
+                let first = line.chars().next().unwrap_or(' ');
+                assert!(!crate::shape::no_line_start(first), "line {i} starts with {first}: {lines:?}");
+            }
+            let last = line.chars().last().unwrap_or(' ');
+            assert!(!crate::shape::no_line_end(last), "line {i} ends with {last}: {lines:?}");
+        }
+    }
+}
+
+/// Each glyph's cell down the (single) column: from its origin over its advance. A glyph that
+/// doesn't advance (the rest of a tate-chu-yoko block) shares the cell of the glyph before it.
+fn column_cells(l: &TextLayout) -> Vec<(f64, f64)> {
+    let mut cells: Vec<(f64, f64)> = Vec::with_capacity(l.glyphs.len());
+    for g in &l.glyphs {
+        let cell = match cells.last() {
+            Some(&prev) if g.advance == 0.0 => prev,
+            _ => (g.origin.y, g.origin.y + g.advance),
+        };
+        cells.push(cell);
+    }
+    cells
+}
+
+/// One column, cells one after the other, each glyph's ink inside its own cell (within `tol`)
+/// and no two glyphs' ink overlapping.
+fn assert_own_cells(l: &TextLayout, text: &str, tol: f64) {
+    let label = |i: usize| &text[l.glyphs[i].byte..l.glyphs[i].byte + l.glyphs[i].len];
+    let cells = column_cells(l);
+    for (i, g) in l.glyphs.iter().enumerate() {
+        assert!((g.origin.x - l.glyphs[0].origin.x).abs() < 1e-9, "{:?} leaves the column: {g:?}", label(i));
+        if let Some(next) = l.glyphs.get(i + 1) {
+            assert!((next.origin.y - (g.origin.y + g.advance)).abs() < 1e-9, "{:?} starts where {:?} ends", label(i + 1), label(i));
+        }
+        if g.outline.elements().is_empty() {
+            continue;
+        }
+        let (r, (top, bottom)) = (ink(l, i), cells[i]);
+        assert!(r.y0 >= top - tol && r.y1 <= bottom + tol, "{:?}: ink {r:?} outside its cell {top}..{bottom}", label(i));
+        for j in (0..i).filter(|&j| !l.glyphs[j].outline.elements().is_empty()) {
+            let o = ink(l, j);
+            let (ox, oy) = (r.x1.min(o.x1) - r.x0.max(o.x0), r.y1.min(o.y1) - r.y0.max(o.y0));
+            assert!(ox <= tol || oy <= tol, "{:?} {r:?} overlaps {:?} {o:?}", label(i), label(j));
+        }
+    }
+}
+
+/// Index of the glyph of `needle`'s first byte in `text`.
+fn glyph_of(l: &TextLayout, text: &str, needle: &str) -> usize {
+    let b = text.find(needle).unwrap();
+    l.glyphs.iter().position(|g| g.byte == b).unwrap()
+}
+
+/// Issue #260 with bundled glyphs (`§` stands in for the upright CJK characters).
+#[test]
+fn numbers_keep_their_own_cells_down_the_column() {
+    let text = "§§ §§§ 10§22§§ 1§ 100§ 2026§";
+    let l = layout(FontDb::global(), &vertical(text));
+    assert_own_cells(&l, text, 0.25);
+    // Tate-chu-yoko: one em of the column, centred on the column's centre line (x = 0), the next
+    // character right after it.
+    for block in ["10§", "22§", "100§"] {
+        let first = glyph_of(&l, text, block);
+        let digits = block.len() - '§'.len_utf8();
+        let after = first + digits;
+        let g = &l.glyphs[first];
+        assert!((g.advance - 20.0).abs() < 1e-9, "{block}: {g:?}");
+        assert!(l.glyphs[first + 1..after].iter().all(|d| d.advance == 0.0), "{block}");
+        assert!((l.glyphs[after].origin.y - (g.origin.y + 20.0)).abs() < 1e-9, "{block}: the next character follows the block's em");
+        let inks = (first..after).map(|i| ink(&l, i)).reduce(|a, b| a.union(b)).unwrap();
+        assert!(inks.center().x.abs() < 1.0, "{block} centred on the column: {inks:?}");
+        assert!((inks.center().y - (g.origin.y + 10.0)).abs() < 1.5, "{block} centred in its em: {inks:?} {g:?}");
+    }
+    // A single digit and longer numbers lie on their side, advancing by their own length.
+    let one = glyph_of(&l, text, "1§");
+    let r = ink(&l, one);
+    assert!(r.width() > r.height() && l.glyphs[one].advance < 20.0, "1 on its side: {r:?}");
+    let year = glyph_of(&l, text, "2026");
+    let len: f64 = l.glyphs[year..year + 4].iter().map(|g| g.advance).sum();
+    assert!(len > 30.0 && (l.glyphs[year + 4].origin.y - l.glyphs[year].origin.y - len).abs() < 1e-9, "2026 takes its length: {len}");
+    // Half-width spaces take their own (narrow) width.
+    for (i, g) in l.glyphs.iter().enumerate().filter(|(_, g)| text[g.byte..].starts_with(' ')) {
+        assert!(g.advance > 2.0 && g.advance < 10.0, "space {i}: {g:?}");
+    }
+}
+
+#[test]
+fn justified_columns_keep_tate_chu_yoko_blocks_whole_and_marks_centred() {
+    let text = "§10§§";
+    let mut t = vertical(text);
+    t.kind = TextKind::Area { frame: PathData::from_bezpath(&Rect::new(0.0, 0.0, 40.0, 200.0).to_path(0.1)) };
+    t.para.justify = Justify::JustifyAll;
+    let l = layout(FontDb::global(), &t);
+    assert_eq!(l.lines.len(), 1);
+    // 200 pt of column, four 20 pt cells: three gaps of 40 pt between them, none inside "10".
+    let (one, zero) = (ink(&l, 1), ink(&l, 2));
+    assert!((one.center().y - zero.center().y).abs() < 0.5 && zero.x0 > one.x1, "10 side by side: {one:?} {zero:?}");
+    let marks: Vec<Rect> = [0, 3, 4].iter().map(|&i| ink(&l, i)).collect();
+    assert!((marks[1].center().y - marks[0].center().y - 120.0).abs() < 1e-6, "{marks:?}");
+    assert!((marks[2].center().y - marks[1].center().y - 60.0).abs() < 1e-6, "{marks:?}");
+    assert!(marks.iter().all(|m| (m.center().x - marks[0].center().x).abs() < 1e-6), "upright marks stay on the centre line: {marks:?}");
+    assert!(marks[2].y1 <= 200.0 + 1e-6, "inside the frame: {marks:?}");
+}
+
+#[test]
+fn tracking_spaces_upright_marks_without_moving_them_off_the_centre_line() {
+    let plain = layout(FontDb::global(), &vertical("§§"));
+    let tracked = layout(FontDb::global(), &vertical_styled("§§", CharStyle { size: 20.0, tracking: 200.0, ..CharStyle::default() }));
+    for i in 0..2 {
+        assert!((ink(&tracked, i).center().x - ink(&plain, i).center().x).abs() < 1e-6, "{:?} {:?}", ink(&tracked, i), ink(&plain, i));
+    }
+    let step = ink(&tracked, 1).center().y - ink(&tracked, 0).center().y;
+    assert!((step - 24.0).abs() < 1e-6, "one em plus 200/1000 em of tracking: {step}");
+}
+
+/// Issue #260 as reported, with a Japanese face of craft-fonts (whose own digits are proportional).
+#[test]
+fn japanese_numbers_keep_their_own_cells_down_the_column() {
+    let Some(face) = crate::craft_fonts::japanese_ui_fonts(false).into_iter().next() else {
+        eprintln!("skipped: built without craft-fonts (set CRAFT_FONTS_DIR to a craft-fonts checkout to run it)");
+        return;
+    };
+    let db = FontDb::with_font_dirs(vec![]);
+    let text = "はただ商店 秋のセール 10月22日まで";
+    let t = vertical_styled(text, CharStyle { size: 28.0, font_family: face.family.into(), font_style: face.style.into(), ..CharStyle::default() });
+    let l = layout(&db, &t);
+    assert!(l.glyphs.iter().filter(|g| !text[g.byte..].starts_with(' ')).all(|g| g.gid != 0), "real glyphs, no tofu");
+    assert_own_cells(&l, text, 0.5);
+    for block in ["10月", "22日"] {
+        let first = glyph_of(&l, text, block);
+        let g = &l.glyphs[first];
+        assert!((g.advance - 28.0).abs() < 1e-9 && l.glyphs[first + 1].advance == 0.0, "{block}: one em");
+        assert!((l.glyphs[first + 2].origin.y - (g.origin.y + 28.0)).abs() < 1e-9, "{block}: the next character follows the em");
+        let inks = ink(&l, first).union(ink(&l, first + 1));
+        assert!(inks.center().x.abs() < 2.8, "{block} centred on the column: {inks:?}");
+    }
+}

crates/tools/src/builder.rs

@@ -243,9 +243,15 @@ pub fn hatch(path: &BezPath, gap: f64) -> BezPath {
 struct RegionCache {
     key: Option<(usize, Vec<NodeId>)>,
     regions: Vec<(po::Region, BezPath, Rect)>,
+    /// Live Paint faces (every path an edge, open ones included) rather than Shape Builder
+    /// regions (the filled areas of the shapes).
+    live: bool,
 }
 
 impl RegionCache {
+    fn live_paint() -> Self {
+        Self { live: true, ..Default::default() }
+    }
     fn get(&mut self, cx: &ToolContext) -> &[(po::Region, BezPath, Rect)] {
         let key = (cx.doc as *const Document as usize, cx.selection.objects.clone());
         if self.key.as_ref() != Some(&key) {
@@ -254,7 +260,8 @@ impl RegionCache {
             self.regions = if shapes.is_empty() {
                 vec![]
             } else {
-                po::regions(&shapes)
+                let regions = if self.live { po::live_paint(&shapes).0 } else { po::regions(&shapes) };
+                regions
                     .into_iter()
                     .filter_map(|r| {
                         let bp = r.path.to_bezpath();
@@ -437,12 +444,17 @@ fn lp_overlays(h: &LpHover, cache: &RegionCache) -> Vec<Overlay> {
 /// Live Paint Bucket: click fills the face under the cursor with the current fill; Shift-click
 /// paints the nearest edge with the current stroke. Clicking selected ordinary paths makes them a
 /// Live Paint group first.
-#[derive(Default)]
 pub struct LivePaintBucketTool {
     cache: RegionCache,
     hover: LpHover,
 }
 
+impl Default for LivePaintBucketTool {
+    fn default() -> Self {
+        Self { cache: RegionCache::live_paint(), hover: LpHover::None }
+    }
+}
+
 impl Tool for LivePaintBucketTool {
     fn id(&self) -> &'static str {
         "livePaintBucket"
@@ -500,12 +512,17 @@ impl Tool for LivePaintBucketTool {
 // ---------- Live Paint Selection ----------
 
 /// Live Paint Selection: click selects a face (Shift adds); Alt-click selects an edge.
-#[derive(Default)]
 pub struct LivePaintSelectionTool {
     cache: RegionCache,
     hover: LpHover,
 }
 
+impl Default for LivePaintSelectionTool {
+    fn default() -> Self {
+        Self { cache: RegionCache::live_paint(), hover: LpHover::None }
+    }
+}
+
 impl Tool for LivePaintSelectionTool {
     fn id(&self) -> &'static str {
         "livePaintSelection"

crates/tools/src/corners.rs

@@ -93,14 +93,15 @@ impl CornerDrag {
         Some(Self { widgets, corner, start: p, began: false, radius: widgets.radii[corner], at: p })
     }
 
-    /// The start radius plus the pointer's travel along the corner's inward diagonal (in the
-    /// shape's own units), from square to fully round.
+    /// The start radius (as drawn: no larger than fits) plus the pointer's travel along the
+    /// corner's inward diagonal (in the shape's own units), from square to fully round.
     fn radius_at(&self, p: Point) -> f64 {
         let w = &self.widgets;
         let inv = w.xf.inverse();
         let d = inv * p - inv * self.start;
         let (_, (sx, sy)) = CORNERS[self.corner];
-        (w.radii[self.corner] + (d.x * sx + d.y * sy) / 2.0).clamp(0.0, w.w.min(w.h) / 2.0)
+        let max = (w.w.abs().min(w.h.abs()) / 2.0).max(0.0);
+        (w.radii[self.corner].min(max) + (d.x * sx + d.y * sy) / 2.0).clamp(0.0, max)
     }
 
     pub fn drag(&mut self, cx: &ToolContext, p: Point) -> Vec<Action> {

crates/tools/src/direct.rs

@@ -7,16 +7,20 @@
 //! Both pick the key objects of a blend. Direct Selection also edits a blend's spine: drag its
 //! points (a key object on a point moves with it) and, once a point is clicked, its handles; and
 //! the points of selected gradient meshes and mesh envelopes and their handles ([`MeshEdit`]).
+//! Dragging a corner or an edge of area type's frame reshapes the type area (`text.reshapeArea`):
+//! the text reflows at its size.
+
+use std::borrow::Cow;
 
 use serde_json::{Value, json};
 use vectorcraft_doc::hit::hit_test;
-use vectorcraft_doc::{AnchorRef, NodeId, NodeKind};
+use vectorcraft_doc::{AnchorRef, Node, NodeId, NodeKind};
 use vectorcraft_geom::{PathData, Point, Rect};
 
 use crate::bbox::move_delta;
 use crate::corners::{CornerDrag, over_widget};
 use crate::meshedit::MeshEdit;
-use crate::select::matrix_json;
+use crate::select::{is_area_type, matrix_json};
 use crate::{Action, Cursor, Mods, Overlay, PointerEvent, PointerKind, Tool, ToolContext};
 
 #[derive(Clone, Debug)]
@@ -58,6 +62,13 @@ enum State {
     },
     /// Dragging a mesh point or handle ([`MeshEdit`]).
     Mesh,
+    /// Dragging anchors of area type's frame (a corner, or the two ends of an edge).
+    TypeArea {
+        id: NodeId,
+        anchors: Vec<AnchorRef>,
+        start: Point,
+        began: bool,
+    },
 }
 
 pub struct DirectSelectionTool {
@@ -115,33 +126,45 @@ fn spine_anchor(cx: &ToolContext, (id, ai): (NodeId, usize)) -> Option<vectorcra
     }
 }
 
-/// Anchor (or handle) of any selected/visible path under `p`.
-fn hit_anchor(cx: &ToolContext, p: Point, tol: f64, selected_only: bool) -> Option<(NodeId, usize, usize)> {
-    let ids: Vec<NodeId> = if selected_only {
-        cx.selection.objects.clone()
-    } else {
-        let mut v = vec![];
-        cx.doc.walk(|n| {
-            if matches!(n.kind, NodeKind::Path { .. }) {
-                v.push(n.id)
-            }
-        });
-        v.reverse();
-        v
-    };
-    for id in ids {
-        if !cx.doc.is_editable(id) {
-            continue;
-        }
-        if let Some(pd) = cx.doc.node(id).and_then(|n| n.path_data()) {
-            for (si, ai, a) in pd.anchors() {
-                if a.p.distance(p) <= tol {
-                    return Some((id, si, ai));
-                }
-            }
-        }
+/// The anchors Direct Selection edits on `n`, in document space: a path's, or area type's frame.
+fn editable_path(n: &Node) -> Option<Cow<'_, PathData>> {
+    match &n.kind {
+        NodeKind::Path { path, .. } => Some(Cow::Borrowed(path)),
+        NodeKind::Text(t) => t.area_frame().map(Cow::Owned),
+        _ => None,
     }
-    None
+}
+
+/// The editable objects `f` accepts, topmost first.
+fn anchor_owners(cx: &ToolContext, f: fn(&Node) -> bool) -> Vec<NodeId> {
+    let mut v = vec![];
+    cx.doc.walk(|n| {
+        if f(n) {
+            v.push(n.id)
+        }
+    });
+    v.reverse();
+    v.retain(|id| cx.doc.is_editable(*id));
+    v
+}
+
+/// Anchor of any visible path or area type frame under `p`, topmost first.
+fn hit_anchor(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, usize, usize)> {
+    let owners = anchor_owners(cx, |n| matches!(n.kind, NodeKind::Path { .. }) || is_area_type(n));
+    owners.into_iter().find_map(|id| {
+        let pd = cx.doc.node(id).and_then(editable_path)?;
+        pd.anchors().find(|(_, _, a)| a.p.distance(p) <= tol).map(|(si, ai, _)| (id, si, ai))
+    })
+}
+
+/// An edge of an area type frame under `p`, topmost first: (text, the edge's two anchors).
+fn hit_frame_edge(cx: &ToolContext, p: Point, tol: f64) -> Option<(NodeId, Vec<AnchorRef>)> {
+    anchor_owners(cx, is_area_type).into_iter().find_map(|id| {
+        let frame = cx.doc.node(id).and_then(editable_path)?;
+        let (si, seg, _, _, d) = frame.nearest(p)?;
+        let n = frame.subpaths.get(si)?.anchors.len();
+        (d <= tol && n > 0).then(|| (id, vec![(si, seg % n), (si, (seg + 1) % n)]))
+    })
 }
 
 /// Direction handle of a partially selected anchor under `p`: (id, si, ai, is_out).
@@ -223,7 +246,10 @@ impl Tool for DirectSelectionTool {
                     self.state = State::SpinePoint { id, anchor, from, start: p, began: false };
                     return if cx.selection.contains(id) { vec![] } else { vec![Action::Exec("select.set".into(), json!({"ids": [id.0]}))] };
                 }
-                if let Some((id, si, ai)) = hit_anchor(cx, p, tol, false) {
+                if let Some((id, si, ai)) = hit_anchor(cx, p, tol) {
+                    if cx.doc.node(id).is_some_and(is_area_type) {
+                        return self.press_type_area(cx, id, vec![(si, ai)], p, ev.mods.shift);
+                    }
                     let already = cx.selection.partial(id).is_some_and(|s| s.contains(&(si, ai)));
                     self.state = State::MoveAnchors { start: p, began: false };
                     if ev.mods.shift {
@@ -234,6 +260,9 @@ impl Tool for DirectSelectionTool {
                     }
                     return vec![];
                 }
+                if let Some((id, anchors)) = hit_frame_edge(cx, p, tol) {
+                    return self.press_type_area(cx, id, anchors, p, ev.mods.shift);
+                }
                 if let Some(h) = hit_test(cx.doc, p, cx.hit_options()) {
                     // Clicking a segment/fill selects the whole leaf path (all anchors).
                     self.state = State::MoveObject { start: p, began: false };
@@ -277,6 +306,19 @@ impl Tool for DirectSelectionTool {
                 ));
                 out
             }
+            (PointerKind::Drag, State::TypeArea { id, anchors, start, began }) => {
+                let mut out = vec![];
+                if !began {
+                    if p.distance(start) < cx.tol(3.0) {
+                        return out;
+                    }
+                    out.push(Action::Begin("Reshape Type Area".into()));
+                }
+                let d = move_delta(start, p, ev.mods.shift);
+                out.push(Action::Preview("text.reshapeArea".into(), json!({"id": id.0, "anchors": anchors_json(&anchors), "dx": d.x, "dy": d.y})));
+                self.state = State::TypeArea { id, anchors, start, began: true };
+                out
+            }
             (PointerKind::Drag, State::Handle { id, si, ai, out }) => {
                 vec![Action::Preview(
                     "path.setHandle".into(),
@@ -318,7 +360,10 @@ impl Tool for DirectSelectionTool {
                 self.state = State::Idle;
                 c.finish()
             }
-            (PointerKind::Up, State::MoveAnchors { began, .. } | State::MoveObject { began, .. } | State::SpinePoint { began, .. }) => {
+            (
+                PointerKind::Up,
+                State::MoveAnchors { began, .. } | State::MoveObject { began, .. } | State::SpinePoint { began, .. } | State::TypeArea { began, .. },
+            ) => {
                 self.state = State::Idle;
                 if began { vec![Action::Commit] } else { vec![] }
             }
@@ -356,6 +401,9 @@ impl Tool for DirectSelectionTool {
             _ => {
                 let mut out = self.spine_overlays(cx);
                 out.extend(self.mesh.overlays(cx));
+                if !self.group {
+                    out.extend(frame_overlays(cx));
+                }
                 out
             }
         }
@@ -368,7 +416,31 @@ impl Tool for DirectSelectionTool {
     }
 }
 
+/// The frame anchors of the selected area type, which Direct Selection drags.
+fn frame_overlays(cx: &ToolContext) -> Vec<Overlay> {
+    let mut out = vec![];
+    for id in &cx.selection.objects {
+        let Some(frame) = cx.doc.node(*id).filter(|n| is_area_type(n)).and_then(editable_path) else { continue };
+        let color = cx.doc.layer_color(*id);
+        out.extend(frame.anchors().map(|(_, _, a)| Overlay::Anchor { p: a.p, color, filled: false, size: 5.0 }));
+    }
+    out
+}
+
 impl DirectSelectionTool {
+    /// Press on area type's frame anchors (a corner, or an edge's two ends): select the text and
+    /// get ready to drag them.
+    fn press_type_area(&mut self, cx: &ToolContext, id: NodeId, anchors: Vec<AnchorRef>, p: Point, shift: bool) -> Vec<Action> {
+        self.state = State::TypeArea { id, anchors, start: p, began: false };
+        if cx.selection.contains(id) {
+            vec![]
+        } else if shift {
+            vec![Action::Exec("select.add".into(), json!({"ids": [id.0]}))]
+        } else {
+            vec![Action::Exec("select.set".into(), json!({"ids": [id.0]}))]
+        }
+    }
+
     /// The clicked spine point, filled, with its handles.
     fn spine_overlays(&self, cx: &ToolContext) -> Vec<Overlay> {
         let Some(sel) = self.spine.filter(|(id, _)| cx.selection.contains(*id)) else { return vec![] };
@@ -435,6 +507,37 @@ mod tests {
         assert_eq!(a, vec![Action::Exec("select.set".into(), json!({"ids": [g.0]}))]);
     }
 
+    #[test]
+    fn dragging_a_frame_corner_or_edge_reshapes_area_type() {
+        let (d, text) = doc_with_area_type();
+        let p = paint();
+        let s = Selection::default();
+        let cx1 = cx(&d, &s, &p);
+        let mut t = DirectSelectionTool::new(false);
+        // The bottom-right corner of the 120 × 40 frame at (300, 300) selects the text...
+        assert_eq!(
+            t.pointer(&cx1, &PointerEvent::new(PointerKind::Down, 421.0, 339.0)),
+            vec![Action::Exec("select.set".into(), json!({"ids": [text.0]}))]
+        );
+        // ...and drags that corner.
+        let a = t.pointer(&cx1, &PointerEvent::new(PointerKind::Drag, 461.0, 399.0));
+        assert_eq!(a[0], Action::Begin("Reshape Type Area".into()));
+        assert_eq!(a[1], Action::Preview("text.reshapeArea".into(), json!({"id": text.0, "anchors": [[0, 2]], "dx": 40.0, "dy": 60.0})));
+        assert_eq!(t.pointer(&cx1, &PointerEvent::new(PointerKind::Up, 461.0, 399.0)), vec![Action::Commit]);
+        // The top edge drags both its ends; a click alone changes nothing.
+        let mut s = Selection::default();
+        s.add(text);
+        let cx2 = cx(&d, &s, &p);
+        assert!(t.pointer(&cx2, &PointerEvent::new(PointerKind::Down, 350.0, 301.0)).is_empty());
+        let a = t.pointer(&cx2, &PointerEvent::new(PointerKind::Drag, 350.0, 281.0));
+        assert_eq!(a[1], Action::Preview("text.reshapeArea".into(), json!({"id": text.0, "anchors": [[0, 0], [0, 1]], "dx": 0.0, "dy": -20.0})));
+        t.pointer(&cx2, &PointerEvent::new(PointerKind::Up, 350.0, 281.0));
+        assert!(t.pointer(&cx2, &PointerEvent::new(PointerKind::Down, 300.0, 340.0)).is_empty());
+        assert!(t.pointer(&cx2, &PointerEvent::new(PointerKind::Up, 300.0, 340.0)).is_empty());
+        // The selected frame's corners show.
+        assert_eq!(t.overlays(&cx2).iter().filter(|o| matches!(o, Overlay::Anchor { filled: false, .. })).count(), 4);
+    }
+
     #[test]
     fn click_anchor_selects_it() {
         let (d, id) = doc_with_rect();